home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DNet / DGopher.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  67.5 KB  |  2,797 lines  |  [TEXT/R*ch]
  1. // DGopher.cp 
  2. // by d.g. gilbert, Mar 1992 
  3. // version for DClap, Jan 94
  4. /*
  5.             This code is Copyright (C) 1992 by D.G. Gilbert.
  6.             All Rights Reserved.
  7.  
  8.             You may use this code for your personal use, to provide a non-profit
  9.             service to others, or to use as a test platform for a commercial
  10.             implementation. 
  11.  
  12.             You may not use this code in a commercial product, nor to provide a
  13.             commercial service, nor may you sell this code without express
  14.             written permission of the author.  
  15.             
  16.             gilbertd@bio.indiana.edu 
  17.             Biology Dept., Indiana University, Bloomington, IN 47405 
  18. */
  19.  
  20.  
  21. #include <ncbi.h>
  22. #include <dgg.h> 
  23.  
  24. #include "DTCP.h"
  25. #include "DURL.h"
  26. #include "DGopher.h"
  27. #include "DGoList.h"
  28. #include "DGoPlus.h"
  29. #include "DGoInit.h"
  30. #include "DGoClasses.h"
  31.  
  32. #include <DFile.h>
  33. #include <DList.h>
  34. #include <DIconLib.h>
  35. #include <DView.h>
  36. #include <DChildApp.h>
  37.  
  38.  
  39. enum  commonTCPports {
  40.     kUnknownPort = 0,
  41.     kUnsupportedPort = 0,
  42.     kFileport = 21,
  43.     kFTPport = 21,
  44.     kSMTPport = 25,
  45.     kTelnetport = 23,
  46.     kTN3270port = 23,
  47.     kWhoisport= 43,
  48.     kGopherport = 70,
  49.     kFingerport = 79,
  50.     kHTTPport = 80,
  51.     kPOPport    = 110,
  52.     kNNTPport = 119,
  53.     kWAISport    = 210
  54.     };
  55.  
  56.         //public variables
  57. //Global const    short kGopherPort    = 70;          // default/prime port #
  58.  
  59. Global const    long     kReadMaxbuf  = 1024;
  60.  
  61. Global DIconList*    gGopherIcons = NULL;
  62. Global short        gGopherIconID;
  63. Global short        gIconSize;
  64.  
  65. Global Boolean    gUseDigFolder;
  66. Global short        gDigVol;
  67. Global long            gDigDirID;
  68.  
  69. Global Boolean    gShortFolder = false;
  70. Global Boolean    gListUnknowns = false;
  71. Global Boolean    gDoSuffix2MacMap = false; // !?? started bombing 26Dec94 w/ this != false
  72.  
  73.  
  74. #if !defined(OS_MAC) && !defined(OS_UNIX) && !defined(OS_DOS) && !defined(OS_VMS)
  75. Global char   *    gLocalGopherRoot = "";
  76. Global char   *    gAskWaisPath = "";
  77. #endif
  78. #ifdef OS_MAC
  79. Global char   *    gLocalGopherRoot = ":";
  80. Global char   *    gAskWaisPath = ":bin:askwais";
  81. #endif
  82. #ifdef OS_UNIX
  83. Global char   *    gLocalGopherRoot = ".";
  84. Global char   *    gAskWaisPath = "/bin/askwais";
  85. #endif
  86. #if defined(OS_DOS) || defined (OS_NT)
  87. Global char   *    gLocalGopherRoot = ".";
  88. Global char   *    gAskWaisPath = "\bin\askwais";
  89. #endif
  90. #ifdef OS_VMS
  91. // damn, what is vms syntax for local subdir ??
  92. Global char   *    gLocalGopherRoot = "[Gopher-root]";
  93. Global char   *    gAskWaisPath = "[bin]askwais.exe";
  94. #endif
  95.  
  96.  
  97.         //private    variables
  98.  
  99. //Local DGopher    *gCurrentGopher;
  100.  
  101. Local const char*    gEmptyString    = "";
  102. Local const char* kDefaultLink = "1Title of gopher link\t\tHost.Name.Goes.Here\t70";    
  103. Local const char* kLocalhost = "localhost";
  104.  
  105. Local const    long     kReadToClose = DTCP::kTCPStopAtclose;
  106. Local const    long     kReadToDotCRLF = DTCP::kTCPStopAtdotcrlf;
  107.  
  108. Local const    long     kReadMaxbuf1 = 1 * 1024; 
  109. Local const    long     kMaxInt = 32000;
  110.  
  111. Local const char *gMonths[13] = 
  112.     {"Jan","Feb","Mar","Apr","May","Jun",  "Jul","Aug","Sep","Oct","Nov","Dec","???"};
  113.  
  114.  
  115.  
  116. // DGopherTalk ------------------------------
  117.  
  118.  
  119. DGopherTalk::DGopherTalk(): DTCP()
  120. {
  121.     fLinesRead= 0;
  122.     NullTerm(false);
  123.     //InstallMessageLine( aStatusLine); 
  124. }
  125.  
  126.  
  127.  
  128. void DGopherTalk::OpenQuery( char* host, short port, char* path, char* query, 
  129.                                                         char* viewchoice, char* plus, DFile* plusFile)
  130. {
  131.     void *crlfdotcrlf = (void*) CRLF"."CRLF; //"\015\012";  
  132.     
  133.     ShowMessage("TCP opening connection to host");
  134.     Open((char*)host, port);
  135.     if (Failed()) return;
  136.     if (!WaitedForOpen(0)) return;
  137.     if (path) Send( path, kDontSendNow); 
  138.     if (query) Send( query, kDontSendNow); 
  139.     if (viewchoice) Send( viewchoice, kDontSendNow); 
  140.     
  141.     if (!plus) {
  142.         SendBytes(crlfdotcrlf, 5, kSendNow);    // send dot-cr-lf 
  143.         }
  144.         
  145.     else {
  146.         // if (plus) send plus data header, form depends on plusFile:
  147.         //char *header0 = "\t+\t1\n\r+NBYTES\n\r";
  148.         //char *header1 = "\t+\t1\n\r+-1\n\r";
  149.         //char *header2 = "\t+\t1\n\r+-2\n\r";
  150.     
  151.         if (!plusFile) {
  152.             if (StrChr(plus, kCR)) { // more than one line in plus == ASK block
  153.                 char    header[80];
  154.                 //long len = strlen(plus);
  155.                 //sprintf( header, "\t+\t1\n\r+%d\n\r", len);  // exactly <len> bytes of data
  156.                     // ^^ this isn't understood by server ?!?
  157. #if 1
  158.     // 1apr94 fix for bad DGoFolder selectors  
  159.     //    bad:  path|+view|+|1<cr>ask data
  160.     //     good:  path|+view|1<cr>data or  path|$|1<cr>data  or  path|+|1<cr>data
  161.                 char* selector= (viewchoice) ? "" : "\t$"; // or "+";
  162.                 sprintf( header, "%s\t1"CRLF"+-1"CRLF, selector); // data until dot-cr-lf
  163. #else
  164.                 sprintf( header, "\t+\t1"CRLF"+-1"CRLF); // data until dot-cr-lf
  165. #endif
  166.                 Send( header, kDontSendNow);
  167.                 Send( plus, kDontSendNow);
  168.                 SendBytes(crlfdotcrlf, 5, kSendNow); 
  169.                 }
  170.             else {
  171.                 Send( plus, kDontSendNow);
  172.                 SendBytes(crlfdotcrlf, 5, kSendNow);     
  173.                 }
  174.             }
  175.             
  176.         else {  //if (plusFile)  
  177.             const short     kMaxBuf = 2048;
  178.             char    buffer[kMaxBuf];
  179.             short    err;
  180.             Boolean fullbuf, done= false;
  181.             long fileType = cTEXT;
  182.             ulong    count, lenFile, fat = 0;
  183.             
  184.             err = plusFile->OpenFile();
  185.             err |= plusFile->GetDataLength( lenFile);
  186.             err |= plusFile->GetFileType( fileType);
  187.  
  188.             if (fileType == cTEXT)  {
  189.                 /// ARrrrgggghhhh -- need to do newline translation here (at least if type==TEXT)
  190.                 char    header[80];
  191.                 sprintf( header, "\t+\t1"CRLF"+-1"CRLF); // data until dot-cr-lf
  192.                 Send( header, kDontSendNow);
  193.                 Send( plus, kDontSendNow);
  194.                 SendCRLF(false, kDontSendNow);        // ensure newline  
  195.                 while (! (done || err)) {
  196.                     count= kMaxBuf;
  197.                     err |= plusFile->ReadUntil( buffer, count, *LineEnd);
  198.                     fullbuf = (count+2 > kMaxBuf);
  199.                     if (buffer[count-1] == kCR) {
  200.                         if (fullbuf) count--;
  201.                         else buffer[count++]= kLF; // add lf;
  202.                         }
  203.                     else {
  204.                         if (!fullbuf) {
  205.                             buffer[count++]= kCR; 
  206.                             buffer[count++]= kLF; 
  207.                             } 
  208.                         }
  209.                     if (count==3 && 0==memcmp(buffer, "."CRLF, 3))  
  210.                         this->SendBytes(".."CRLF, 4, kDontSendNow); // make sure we don't send terminator by mistake
  211.                     else
  212.                         this->SendBytes(buffer, count, kSendNow); //kDontSendNow
  213.                     if (fullbuf) this->SendCRLF(kDontSendNow);
  214.                     
  215.                     err |= plusFile->GetDataMark(fat);
  216.                     done|= fat >= lenFile;
  217.                     }
  218.                 SendCRLF(false, kDontSendNow);        // ensure newline  
  219.                 SendBytes("."CRLF, 3, kSendNow);    // send dot-cr-lf 
  220.                 }
  221.             
  222.             else {
  223.                 char    header[80];
  224.                 long len = strlen(plus) + lenFile;
  225.                 //sprintf( header, "\t+\t1"CRLF"+%d"CRLF, len);  // exactly <len> bytes of data
  226.                         // ^^ this isn't understood by server ?!?
  227.                 sprintf( header, "\t+\t1"CRLF"+-2"CRLF); // data until close
  228.                 Send( header, kDontSendNow);
  229.                 Send( plus, kDontSendNow);
  230.                 //SendCRLF(false, kDontSendNow);        // ??! ensure newline  -- not w/ fixed bytecount...
  231.                 while (! (done || err)) {
  232.                     count= kMaxBuf;
  233.                     err |= plusFile->ReadData( buffer, count);
  234.                     this->SendBytes(buffer, count, kSendNow);
  235.                     err |= plusFile->GetDataMark(fat);
  236.                     done|= fat >= lenFile;
  237.                     }
  238.                 }
  239.                 
  240.              err= plusFile->CloseFile();
  241.             }
  242.         }
  243.         
  244. //  long ticktock= TickCount() + fTimeout;
  245. //    while (!CharsAvailable() && TickCount() < ticktock && !UserBreak() )
  246. //            StatusMessage();            
  247.     SetShowProgress( true);
  248.  
  249. }
  250.  
  251.  
  252.  
  253.  
  254. Boolean DGopherTalk::ReadALine( CharPtr appendToHandle, CharPtr& result)
  255. {    
  256.     result= NULL;
  257.     fResultNew= 0;
  258.     CharPtr data= RecvLine(); //RecvUpTo( true, kLF, NULL);  // includes lf+null at end
  259.     //- fEndofMessage= false; << !?! RecvUpTo NO LONGER sets this true at Linefeed ?
  260.     Boolean readone= (data!=NULL);
  261.     fLinesRead++;
  262.     if (readone) {
  263.         if ( data[0] == '.' &&  data[1] == kCR) fEndofMessage= true; 
  264.                 //  ^^ this changes w/ subclasses...
  265.  
  266.                 // some damn terminator patching -- always end string w/ Return, no lf or null 
  267.         long    len= StrLen(CharPtr(data));
  268.         //len--; //drop null, always there from RecvUpTo() << NO, 
  269.         //if (len < kMaxInt) << do we need to stop at 32K ??
  270.         {
  271.             if ( data[len-1] == kLF) len--;
  272.             if ( data[len-1] != kCR) data[len++]= *LineEnd; 
  273.             }
  274.         data= (char*) MemMore( data, Max(0,len));
  275.         
  276.         if (appendToHandle == NULL)
  277.             appendToHandle= data;
  278.         else {
  279.             long oldlen= StrLen(appendToHandle);
  280.             appendToHandle= (char*)MemMore( appendToHandle, oldlen+len+1);
  281.             MemCopy( appendToHandle+oldlen, data, len);
  282.             appendToHandle[oldlen+len]= 0;
  283.             }
  284.         }
  285.     result= appendToHandle;
  286.     return readone;
  287. }
  288.  
  289.  
  290.  
  291.  
  292.  
  293.  
  294. // DocLink ------------------------------
  295.  
  296.  
  297. DocLink::DocLink() : 
  298.     fType(kNoLink), fParag(0), fChar(0)
  299. {
  300.     string.fString= NULL;
  301. }
  302.  
  303. DocLink::~DocLink()  
  304. {
  305.     if (fType == kString) MemFree( string.fString);
  306. }
  307.  
  308. void DocLink::Clear() 
  309. { 
  310.     if (fType == kString) MemFree( string.fString);
  311.     fType= kNoLink; 
  312. }
  313.         
  314. void DocLink::DupData()
  315. {
  316.     if (fType == kString) 
  317.         string.fString= StrDup( string.fString);
  318. }
  319.         
  320. char * DocLink::GetString( short& skipval) 
  321. { 
  322.     skipval= string.fSkip; 
  323.     return string.fString; 
  324. }
  325.  
  326. void DocLink::SetString( const char* thestr, short skipvalue)
  327. {
  328.     Clear();
  329.     fType= kString;
  330.     string.fString= StrDup(thestr);
  331.     string.fSkip= skipvalue;
  332. }
  333.  
  334. void DocLink::SetSkip( short skipvalue) 
  335. { 
  336.     if (fType == kString) string.fSkip= skipvalue; 
  337. }
  338.  
  339. void DocLink::SetRect( Nlm_RecT therect)
  340. {
  341.     Clear();
  342.     fType= kRect;
  343.     rect.fRect= therect;
  344. }
  345.  
  346. void DocLink::GetLine( short& atparag, short& atchar, short& endparag, short& endchar )
  347. {
  348.     atparag= fParag;
  349.     atchar= fChar;
  350.     endparag= line.fEndParag;
  351.     endchar= line.fEndChar;
  352. }
  353.     
  354. void DocLink::SetLine( short atparag, short atchar, short endparag, short endchar )
  355. {
  356.     Clear();
  357.     fType= kLine;
  358.     fParag= atparag;
  359.     fChar= atchar;
  360.     line.fEndParag= endparag;
  361.     line.fEndChar= endchar;
  362. }
  363.  
  364. void DocLink::GetLineRect( Nlm_RecT& therect, short& atparag, short& atchar )
  365. {
  366.     therect= rect.fRect;
  367.     atparag= fParag;
  368.     atchar= fChar;
  369. }
  370.     
  371. void DocLink::SetLineRect( Nlm_RecT therect, short atparag, short atchar)
  372. {
  373.     Clear();
  374.     fType= kLineRect;
  375.     fParag= atparag;
  376.     fChar= atchar;
  377.     rect.fRect= therect;
  378. }
  379.  
  380.  
  381.  
  382.  
  383.  
  384. // DGopherAbstract ------------------------------
  385.  
  386. class DGopherAbstract : public DObject
  387. {
  388. public:
  389.     short fLines;
  390.     long    fSize;
  391.     char* fText;
  392.     
  393.     DGopherAbstract( char* text);
  394.     ~DGopherAbstract() { Clear(); }
  395.     
  396.     virtual DObject* Clone();
  397.     void Set( const char* text);
  398.     void Clear();
  399.     void Install( const char* text) { Clear(); Set( text); }
  400.     void Draw( Nlm_RecT& area);
  401.     short Height();
  402. };
  403.  
  404. DGopherAbstract::DGopherAbstract( char* text) : 
  405.         fLines(0), fSize(0), fText(NULL) 
  406. { 
  407.     Set( text); 
  408. }
  409.  
  410. void DGopherAbstract::Clear()
  411. {
  412.     MemFree( fText);
  413.     fSize= fLines= 0;
  414. }
  415.  
  416. DObject* DGopherAbstract::Clone()
  417. {
  418.     DGopherAbstract* myClone= (DGopherAbstract*) DObject::Clone();
  419.     myClone->fText= StrDup(fText);
  420.     return myClone;
  421. }
  422.  
  423. void DGopherAbstract::Set( const char* text)
  424. {
  425.     char *cp, *dp, c, lastc;
  426.     Boolean havevis= false;
  427.     long bytes= StringLen( text);
  428.     if (bytes>0) {
  429.         fText= (char*) MemNew( bytes+1);
  430.         fLines= 1;
  431.         for (cp= (char*)text, dp= fText, lastc= 0; *cp != 0; cp++) {
  432.             c= *cp;
  433.             if (c == kCR) { 
  434.                 if (havevis) { *dp++= NEWLINE;  fLines++; }
  435.                 }
  436.             else if (c == kLF) {
  437.                 if (lastc == kCR) ; // eat c
  438.                 else if (havevis) { *dp++= NEWLINE;  fLines++; }
  439.               }
  440.             else if (havevis) *dp++= c; 
  441.             else { havevis= isgraph(c); if (havevis) *dp++= c; }
  442.             lastc= c;
  443.             }
  444.         while ( fLines && dp > fText && dp[-1] == NEWLINE) { 
  445.              // drop trailing blank lines
  446.             fLines--; dp--; 
  447.             }    
  448.       *dp= 0;
  449.       fSize= dp - fText;
  450.       }
  451. }
  452.  
  453. void DGopherAbstract::Draw( Nlm_RecT& area)
  454. {
  455.     if (fText) {
  456.         //? Nlm_DrawString(&area, fText, 'l', false);
  457.         Dgg_DrawTextbox( &area, fText, fSize, 'l', false);
  458.         }
  459. }
  460.  
  461. short DGopherAbstract::Height()
  462. {
  463.     if (fLines) 
  464.         return (fLines * Nlm_LineHeight());
  465.     else 
  466.         return 0;
  467. }
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477. // DGopher ------------------------------
  478.  
  479.  
  480. DGopher::DGopher( char ctype, const char* link) :
  481.     DTaskMaster( 0, NULL, NULL)
  482. {
  483.     Initialize();
  484.     SetLink( ctype, link);
  485. }
  486.  
  487. DGopher::DGopher() :
  488.     DTaskMaster( 0, NULL, NULL)
  489. {
  490.     Initialize();
  491.     SetLink( *kDefaultLink, kDefaultLink);
  492. }
  493.  
  494. DGopher::DGopher( DGopher* aGopher)  :
  495.     DTaskMaster( 0, NULL, NULL) 
  496. {
  497.     Initialize();
  498.     CopyGopher( aGopher);
  499. }
  500.  
  501.  
  502. DGopher::~DGopher()  
  503. {
  504.     DeleteLink(false);
  505.     fInfo= (char*) MemFree( fInfo);
  506. }
  507.  
  508. Boolean DGopher::suicide(void) 
  509. { 
  510.     if (GetOwnerCount() <= 1) { 
  511.         delete this; 
  512.         return true; 
  513.         }
  514.     else 
  515.         return DObject::suicide();
  516. }
  517.  
  518. Boolean DGopher::suicide(short ownercount)
  519. {
  520.     if (ownercount < 1) {
  521.         delete this; 
  522.         return true; 
  523.         }
  524.     else 
  525.         return DObject::suicide(ownercount);
  526. }
  527.  
  528. DObject* DGopher::Clone()
  529. {
  530.     //DGopher* aGopher= (DGopher*)DObject::Clone();
  531.     DGopher* aGopher= new DGopher();
  532.     aGopher->CopyGopher( this);
  533.     return aGopher;
  534. }
  535.  
  536.  
  537.  
  538. void DGopher::Initialize()
  539. {
  540.     fLink= NULL;
  541.     fLinkLen= 0;
  542.     fItitle= 0;
  543.     fIdate = 0;     
  544.     fIsize = 0;     
  545.     fIpath = 0;     
  546.     fIhost = 0;     
  547.     fIport = 0;     
  548.     fIplus = 0; 
  549.  
  550.     fType    = kTypeError; //== ancestor doesn't know much...
  551.     fProtocol = kGopherprot;
  552.     fIsLocal= false;
  553.     fPort    = kGopherport;
  554.     fURL= NULL;
  555.     fDate= NULL; fDateLong= 0;
  556.     fDataSize= NULL; fSizeLong= 0;
  557.     fInfo= NULL;
  558.     fInfoSize= 0;
  559.     fInfoHandler= NULL;
  560.     
  561.     fOwnerList= NULL;
  562.     fStatusLine= NULL;
  563.  
  564.     fDeleted= false;
  565.     fInUseCount= 1;
  566.     fTalker= NULL;
  567.     fMacType= cTEXT;
  568.     fMacSire= cEDIT;
  569.     fTransferType= kTransferText; //text/lines or binary or none ?
  570.     fSaveToDisk= false;
  571.     fLaunch= false;
  572.     fQuery= NULL;
  573.     fQueryGiven= NULL;
  574. #if 1
  575.     fDocLink= NULL;    //ClearDocLink();
  576. #else
  577.     fMenuString= NULL;
  578.     fMenuStringSkip= 0;
  579.     fDocLinkParag= 0;
  580.     fDocLinkChar= 0;
  581.     fDocLinkLen= 0;
  582. #endif
  583.  
  584.     fCommand= cNoCommand;
  585.     fThreadState= kThreadNotStarted;
  586.     fBytesExpected= 0;
  587.     fBytesReceived= 0;
  588.     fConnectTime= 0;    
  589.     fAppFile= NULL;
  590.     
  591.         // gopher+
  592.     fShortFolder= gShortFolder; //false;
  593.     fHasAsk= false;
  594.     fIsMap= false;
  595.     fHaveReply= false;
  596.     fReplyFile= NULL;
  597.     fReplyData= NULL;
  598.     fIsPlus= kGopherPlusDontKnow;
  599.     fQueryPlus= NULL;
  600.     fAdminEmail= NULL;
  601.     fViews= NULL;                    // list of CGopherItemView
  602.     fViewchoice= 0;
  603.     fAskers    = NULL;
  604.     fAbstract= NULL;
  605.     fGoMenuBlock= NULL;
  606.     fInfo    = (char*)Nlm_MemGet(1, true); 
  607.     fInfoSize= 0; // fInfoSize is size of data not including terminating NULL !@!@$#@# 
  608. }
  609.  
  610. void DGopher::CopyGopher( DGopher* aGopher)  
  611. {
  612.     if (aGopher) {
  613.     // This memcpy was bad...problem was NULL aGopher !!!
  614.     //memcpy(&fType, &aGopher->fType, sizeof(DGopher)); //<< bad for subclass w/ larger size !
  615.  
  616.     fType     = aGopher->fType;                  
  617.     fItitle    = aGopher->fItitle; 
  618.     fIdate    = aGopher->fIdate;         
  619.     fIsize    = aGopher->fIsize; 
  620.     fIpath    = aGopher->fIpath; 
  621.     fIhost    = aGopher->fIhost;     
  622.     fIport    = aGopher->fIport;     
  623.     fIplus    = aGopher->fIplus;     
  624.     fPort        = aGopher->fPort;      
  625.     fLink        = (char*) MemDup( aGopher->fLink, aGopher->fLinkLen);
  626.     fLinkLen= aGopher->fLinkLen;
  627.  
  628.     fDate        = (char*) StrDup( (CharPtr)aGopher->fDate);
  629.     fDateLong    = aGopher->fDateLong;     
  630.     fDataSize    = (char*) StrDup( (CharPtr)aGopher->fDataSize);
  631.     fSizeLong = aGopher->fSizeLong;     
  632.  
  633.     fAdminEmail= (char*) StrDup( (CharPtr)aGopher->fAdminEmail);    
  634.     fViews    = aGopher->CloneViews();
  635.     fAskers    = aGopher->CloneAskers();
  636.     if (aGopher->fAbstract) fAbstract = (DGopherAbstract*) aGopher->Clone(); 
  637.     fIsPlus    = aGopher->fIsPlus;         
  638.     fShortFolder    = aGopher->fShortFolder; 
  639.     fHasAsk    = aGopher->fHasAsk;         
  640.     fHaveReply = aGopher->fHaveReply;     
  641.     if (aGopher->fReplyFile) fReplyFile = (DFile*) aGopher->fReplyFile->Clone();     
  642.     fReplyData = StrDup( aGopher->fReplyData);         
  643.     if (aGopher->fGoMenuBlock) fGoMenuBlock= new DGoMenuBlock(this, aGopher->fGoMenuBlock->fData);
  644.     else fGoMenuBlock= NULL;
  645.  
  646.     fProtocol= aGopher->fProtocol;      
  647.     fURL        = (char*) StrDup( (CharPtr)aGopher->fURL);
  648.     fIsLocal= aGopher->fIsLocal;
  649.     fIsMap    = aGopher->fIsMap;         
  650.  
  651.     MemFree( fInfo); 
  652.     fInfoSize= aGopher->fInfoSize;
  653.     fInfo= (char*)MemDup( aGopher->fInfo, fInfoSize+1);
  654.     fInfoHandler= aGopher->fInfoHandler; //??
  655.     
  656.     fQuery = aGopher->fQuery;             
  657.     fQueryPlus = aGopher->fQueryPlus;    
  658.     fQueryGiven = StrDup( aGopher->fQueryGiven);         
  659.     
  660.     //fTransferType    = aGopher->fTransferType;  
  661.     //fDeleted= false;
  662.     //fMacType    = aGopher->fMacType;             // PRESERVE for CopyToNewKind
  663.     //fMacSire    = aGopher->fMacSire;            // PRESERVE for CopyToNewKind
  664.     //fSaveToDisk    = aGopher->fSaveToDisk;    // PRESERVE for CopyToNewKind
  665.     //fLaunch        = aGopher->fLaunch;                // PRESERVE for CopyToNewKind
  666.     //fCommand    = aGopher->fCommand;             // PRESERVE for CopyToNewKind
  667.     //fViewchoice    = aGopher->fViewchoice;    // PRESERVE for CopyToNewKind
  668.     //fOwnerList= NULL; //!? 
  669.     fStatusLine= aGopher->fStatusLine; 
  670.     //fTalker= NULL;        //? 
  671.     fBytesExpected= aGopher->fBytesExpected;
  672.     //fBytesReceived= aGopher->fBytesReceived;
  673.     //fConnectTime= aGopher->fConnectTime;
  674.     //fThreadState= aGopher->fThreadState; 
  675.     //fAppFile = NULL; //??
  676.     //fInUseCount= 1;
  677.     fDocLink= aGopher->fDocLink;
  678.     if (fDocLink) fDocLink->DupData();
  679.     }
  680. }
  681.  
  682. void DGopher::DeleteInfo()
  683. {
  684.     if (fInfo) fInfo= (char*) MemMore( fInfo, 1);
  685.     else fInfo= (char*) MemNew(1);
  686.     *fInfo= 0;
  687.     fInfoSize= 0;
  688. }
  689.  
  690. void DGopher::DeleteViews()  
  691. {
  692.     if (fViews) {
  693.         fViews->FreeAllObjects();
  694.         fViews->suicide();
  695.         fViews= NULL;
  696.         }
  697. }
  698.  
  699. DList* DGopher::CloneViews()  
  700. {
  701.     DList* newViews= NULL;
  702.     if (fViews) {
  703.         newViews= new DList();
  704.         long i, n= fViews->GetSize();
  705.         for (i= 0; i<n; i++) newViews->InsertLast( fViews->At(i)->Clone());
  706.         }
  707.     return newViews;
  708. }
  709.  
  710.  
  711. void DGopher::DeleteAskers()  
  712. {
  713.     if (fAskers) {
  714.         fAskers->FreeAllObjects();
  715.         fAskers->suicide();
  716.         fAskers= NULL;
  717.         }
  718. }
  719.  
  720. DList* DGopher::CloneAskers()  
  721. {
  722.     DList* newAskers= NULL;
  723.     if (fAskers) {
  724.         newAskers= new DList();
  725.         long i, n= fAskers->GetSize();
  726.         for (i= 0; i<n; i++) newAskers->InsertLast( fAskers->At(i)->Clone());
  727.  
  728.         }
  729.     return newAskers;
  730. }
  731.  
  732.  
  733.  
  734. void DGopher::DeleteLink(Boolean onlyInfoline)  
  735. {
  736.     fLink    =  (char*) MemFree( fLink);
  737.     fLinkLen= 0;
  738.         // zero the indices into flink
  739.      fItitle = fIdate= fIsize= fIpath= fIhost= fIport= fIplus = 0;
  740.  
  741.     if (!onlyInfoline) {    
  742.         if (fDate) fDate    = (char*)MemFree( (CharPtr)fDate);    
  743.         if (fDataSize) fDataSize= (char*)MemFree( (CharPtr)fDataSize);
  744.         if (fAppFile) fAppFile= (char*)MemFree( fAppFile);
  745.         if (fAdminEmail) fAdminEmail    = (char*)MemFree( (CharPtr)fAdminEmail);    
  746.         if (fGoMenuBlock) { delete fGoMenuBlock; fGoMenuBlock= NULL; }
  747.         if (fAbstract) { delete fAbstract; fAbstract= NULL;  }
  748.         if (fQueryGiven) fQueryGiven= (char*)MemFree( fQueryGiven);
  749. #if 1
  750.         if (fDocLink) delete fDocLink; fDocLink= NULL;
  751. #else
  752.         if (fMenuString) fMenuString= (char*)MemFree( fMenuString);
  753. #endif
  754.  
  755.         DeleteViews();
  756.         DeleteAskers();
  757.         }
  758. }
  759.  
  760.  
  761.  
  762.  
  763. Boolean DGopher::HasDocLink()
  764. {
  765.     return (fDocLink && fDocLink->HasLink());
  766.     //return (fDocLinkParag || fDocLinkChar || fDocLinkLen);
  767. }
  768.  
  769. #if 0
  770. void DGopher::GetDocLink( short& atParagraph, short& atChar, short& length)
  771. {
  772.     atParagraph= fDocLinkParag;
  773.     atChar= fDocLinkChar;
  774.     length= fDocLinkLen;
  775. }
  776.  
  777. void DGopher::SetDocLink( short atParagraph, short atChar, short length)
  778. {
  779.     fDocLinkParag= atParagraph;
  780.     fDocLinkChar= atChar;
  781.     fDocLinkLen= length;
  782. }
  783.  
  784. void DGopher::ClearDocLink()
  785. {
  786.     fDocLinkParag= 0;
  787.     fDocLinkChar= 0;
  788.     fDocLinkLen= 0;
  789. }
  790. #endif
  791.  
  792.  
  793.  
  794. void DGopher::AddView( const char* viewkind)
  795. {
  796.     if (!fViews) fViews = new DList();
  797.     DGopherItemView* giv= new DGopherItemView( viewkind);
  798.     fViews->InsertLast( giv);
  799. }
  800.  
  801.  
  802. void DGopher::SetPlusInfo( short isPlus, Boolean hasAsk, char* plus)
  803. {
  804.     char *cp, *ep, ec, ecl, *sp, *sep, cep;
  805.     Boolean done= false;
  806.     Boolean isHTMLform= false;
  807.     
  808. #define FindNextPlus(cp)     { \
  809.     for (ep=cp,ecl=*(cp-1),ec=*ep; ec!=0 && !((ec=='.' || ec=='+') && ecl<' '); ) \
  810.         {ecl= ec; ec= *(++ep);} }
  811.     
  812.     fIsPlus= isPlus;
  813.     fHasAsk= hasAsk;
  814.     ClearAskReply();
  815.     if (!plus) return;
  816.  
  817.     cp= plus;
  818.     while (*cp!=0) {
  819.         while (*cp!='+' && *cp!=0) cp++;
  820.         
  821.         if (0==Strncasecmp(cp, "+ADMIN:",7)) {
  822.             cp += 7;
  823.             FindNextPlus(cp);
  824.             while (cp < ep) {
  825.                 while (*cp <= ' ' && *cp!=0 && cp<ep) cp++; // skip whitespace, newlines
  826.                 if (0==Strncasecmp(cp, "Admin:",6)) {
  827.                     // Admin: Don Gilbert  <archive@bio.indiana.edu>
  828.                     MemFree((CharPtr)fAdminEmail);
  829.                     sp = cp + 6;
  830.                     for (sep= sp; *sep >= ' ' && sep<ep; sep++) ; // skip over other words
  831.                     cep= *sep; *sep= 0;
  832.                     fAdminEmail= (char*)StrDup(sp);
  833.                     *sep= cep;
  834.                     }
  835.                     
  836.                 else if (0==Strncasecmp(cp, "Mod-Date:",9)) {
  837.                     sp= StrChr(cp,'<');
  838.                     if (sp) {
  839.                             // Mod-Date: Thu Feb  4 13:46:47 1993 <19930204134647>
  840.                             // convert <19930204134647> to 04Feb93
  841.                         char    sdate[50];
  842.                         sp++;
  843.                         // save complete date for sorts, etc.
  844.                         sep= sp+10; cep= *sep; *sep= 0;
  845.                         fDateLong= atol(sp);
  846.                         *sep= cep;
  847.  
  848.                         sdate[0]= 0;
  849.                         sep= sp+6; //day
  850.                         strncat(sdate, sep, 2);
  851.                         
  852.                         sep= sp+6; cep= *sep; *sep= 0;
  853.                         long i= atol(sp+4);  // month
  854.                         *sep= cep;
  855.                         if (i<1 || i>12) strncat(sdate, gMonths[12], 3);
  856.                         else strncat(sdate, gMonths[i-1], 3);
  857.                         strncat( sdate, sp+2, 2); // year
  858.                         MemFree((CharPtr)fDate);
  859.                         fDate= (char*) StrDup( sdate);
  860.                         }
  861.                     }
  862.                 while (*cp >= ' ' && *cp!=0 && cp<ep) cp++; // skip over other words
  863.                 }
  864.             } // +ADMIN
  865.             
  866.         else if (0==Strncasecmp(cp, "+VIEWS:",7)) {
  867.             cp += 7;
  868.             FindNextPlus(cp);
  869.             DeleteViews();
  870.             fViews = new DList();
  871.             while (cp < ep) {
  872.                 while (*cp <= ' ' && *cp!=0 && cp<ep) cp++; // skip whitespace, newlines
  873.                 if (*cp!=0 && cp<ep) {
  874.                     for (sep= cp; *sep >= ' ' && sep<ep; sep++) ; // skip over other words
  875.                     cep= *sep; *sep= 0;
  876.                     DGopherItemView* giv= new DGopherItemView( cp);
  877.                     fViews->InsertLast( giv);
  878.                     if (fDataSize==NULL) {
  879.                         fSizeLong= atol( (char*) giv->DataSize());
  880.                         char snum[50];
  881.                         if (fSizeLong) sprintf( snum, "%luk", fSizeLong);
  882.                         else strcpy(snum,"<1k");
  883.                         fDataSize= (char*) StrDup( snum);
  884.                         }
  885.                     *sep= cep;
  886.                     cp= sep;
  887.                     }        
  888.                 }
  889.             } // +VIEWS
  890.             
  891.         else if (0==Strncasecmp(cp, "+ASKHTML:",9)) {
  892.             // this format is like +ASK except each item has HTML name tag immediately
  893.             // after ask kind:  " Choose:name:label\tchoice1\tchoice2"
  894.             // " Ask:name2:label2\tstring"
  895.             cp += 9; 
  896.             isHTMLform= true;
  897.             goto HandleAskForm;
  898.             }
  899.             
  900.         else if (0==Strncasecmp(cp, "+ASK:",5)) {
  901.             cp += 5;
  902.             isHTMLform= false;
  903. HandleAskForm:
  904.             FindNextPlus(cp);
  905.             DeleteAskers();
  906.             fAskers = new DList;
  907.             while (cp < ep) {
  908.                 while (*cp <= ' ' && *cp!=0 && cp<ep) cp++; // skip whitespace, newlines
  909.                 if (*cp!=0 && cp<ep) {
  910.                     for (sep= cp; (*sep>=' ' || *sep== '\t') && sep<ep; sep++) ; // skip over other words
  911.                     cep= *sep; *sep= 0;
  912.                     DGopherItemAsk* gia= new DGopherItemAsk( cp, isHTMLform);
  913.                     if (gia && gia->fKind == kGopherAskUnknown) delete gia;
  914.                     else fAskers->InsertLast( gia);
  915.                     *sep= cep;
  916.                     cp= sep;
  917.                     }        
  918.                 }
  919.             }  //+ASK
  920.             
  921.         else if (0==Strncasecmp(cp, "+ABSTRACT:",10)) {
  922.             cp += 10;
  923.             FindNextPlus(cp);
  924.             cep= *ep; *ep= 0;
  925.             if (fAbstract) fAbstract->Install( cp); 
  926.             else fAbstract= new DGopherAbstract( cp); 
  927.             *ep= cep;
  928.             } //+ABSTRACT
  929.  
  930.         else if (0 == Strncasecmp( cp, "+URL:", 5) ) {
  931.             cp += 5;
  932.             FindNextPlus(cp);
  933.             //if (fURL) MemFree( fURL);
  934.             cep= *ep; *ep= 0;
  935. #if 0
  936.             if ( DURL::ParseURL( this, cp, ep-cp) ) ;
  937. #else
  938.             char* saven= StrDup( (char*)this->GetName());
  939.             if ( DURL::ParseURL( this, cp, ep-cp) ) ;
  940.             if (saven && *saven) this->StoreName(saven); 
  941.             MemFree(saven);
  942. #endif
  943.             *ep= cep;
  944.             }
  945.  
  946.         else if (0==Strncasecmp(cp, "+ISMAP",6)) {  // dgg addition
  947.             cp += 6;
  948.             FindNextPlus(cp);
  949.             fIsMap= true;
  950. // having problems w/ other settings !?!?
  951. // ?? need special map type ?
  952.             fIsPlus= kGopherPlusYes;
  953.             fTransferType= kTransferBinary; 
  954.             //fCommand= cNewGopherText; // ???
  955.             } //+ISMAP
  956.             
  957.         else if (0==Strncasecmp(cp, "+MENU:",6)) { // dgg addition
  958.             cp += 6;
  959.             //FindNextPlus(cp);
  960.             Boolean found= false;
  961.             ep= cp; 
  962.             ecl= *(cp-1);
  963.             ec= *ep; 
  964.             while (!found) {
  965.                 ecl= ec; 
  966.                 ++ep;
  967.                 ec= *ep;
  968.                 if (ec == 0) found= true;
  969.                 else if ((ecl == kCR || ecl == kLF) && (ec == '+' || ec == '.')) found= true;
  970.                 }  
  971.  
  972.             if (fGoMenuBlock) delete fGoMenuBlock;
  973.             cep= *ep; *ep= 0;
  974.             fGoMenuBlock= new DGoMenuBlock(this, cp);
  975.             *ep= cep;
  976.             } //+MENU
  977.             
  978.         // +MENUSTRING:
  979.         else if (0==Strncasecmp(cp, "+MENUSTRING:",12)) { // dgg addition
  980.             cp += 12;
  981.             while (*cp && *cp <= ' ') cp++;
  982.             if (*cp == '"') {
  983.                 cp++; ep= cp;
  984.                 while (*ep && *ep != '"') ep++;
  985.                 }
  986.             else if (*cp == '\'') {
  987.                 cp++; ep= cp;
  988.                 while (*ep && *ep != '\'') ep++;
  989.                 }
  990.             else {
  991.                 ep= cp;
  992.                 while (*ep && *ep > ' ') ep++;
  993.                 }
  994.             cep= *ep; *ep= 0;
  995.             //if (fMenuString) MemFree(fMenuString);
  996.             //fMenuString= StrDup(cp);
  997.             if (!fDocLink) fDocLink= new DocLink();
  998.             fDocLink->SetString( cp);
  999.             *ep= cep;
  1000.             
  1001.                 // look for skip value
  1002.             cp= ep; if (*cp) cp++;
  1003.             while (*cp && *cp <= ' ') cp++;
  1004.             if (isdigit(*cp)) 
  1005.                 fDocLink->SetSkip( atol(cp)); 
  1006.                 //fMenuStringSkip= atol( cp);
  1007.             
  1008.             FindNextPlus(cp);
  1009.             }
  1010.  
  1011.             // +MENULINE:  #parag  #startchar  #endparag  #stopchar
  1012.         else if (0==Strncasecmp(cp, "+MENULINE:",10)) { // dgg addition
  1013.             cp += 10;
  1014.             short  atpar, atchar, endpar, endchar;
  1015. #if 1
  1016.             while (*cp && *cp <= ' ') cp++;
  1017.             atpar= atol( cp);
  1018.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1019.             atchar= atol( cp);
  1020.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1021.             endpar= atol( cp);
  1022.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1023.             endchar= atol( cp);
  1024. #else
  1025.     // bad, skipping 1st number !!
  1026.             sscanf( cp, "%d%d%d%d", &atpar, &atchar, &endpar, &endchar);
  1027. #endif
  1028.             if (!fDocLink) fDocLink= new DocLink();
  1029.             fDocLink->SetLine( atpar, atchar, endpar, endchar);
  1030.             FindNextPlus(cp);
  1031.             }
  1032.  
  1033.             // +MENURECT:  #left  #top  #right  #bottom
  1034.         else if (0==Strncasecmp(cp, "+MENURECT:",10)) { // dgg addition
  1035.             short  left, top, right, bottom;
  1036.             Nlm_RecT    r;
  1037.             cp += 10;
  1038. #if 1
  1039.             while (*cp && *cp <= ' ') cp++;
  1040.             left= atol( cp);
  1041.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1042.             top= atol( cp);
  1043.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1044.             right= atol( cp);
  1045.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1046.             bottom= atol( cp);
  1047. #else
  1048.     // bad, skipping 1st number !!
  1049.             sscanf( cp, "%d %d %d %d ", &left, &top, &right, &bottom);
  1050. #endif
  1051.             Nlm_LoadRect( &r, left, top, right, bottom);
  1052.             if (!fDocLink) fDocLink= new DocLink();
  1053.             fDocLink->SetRect(r);
  1054.             FindNextPlus(cp);
  1055.             }
  1056.  
  1057.             // +MENULINERECT:  #parag #startchar #left  #top  #right  #bottom
  1058.         else if (0==Strncasecmp(cp, "+MENULINERECT:",14)) { // dgg addition
  1059.             short  atpar, atchar, left, top, right, bottom;
  1060.             Nlm_RecT    r;
  1061.             cp += 14;
  1062. #if 1
  1063.             while (*cp && *cp <= ' ') cp++;
  1064.             atpar= atol( cp);
  1065.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1066.             atchar= atol( cp);
  1067.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1068.             left= atol( cp);
  1069.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1070.             top= atol( cp);
  1071.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1072.             right= atol( cp);
  1073.             while (isdigit(*cp)) cp++; while (*cp && *cp <= ' ') cp++;
  1074.             bottom= atol( cp);
  1075. #else
  1076.     // bad, skipping 1st number !!
  1077.             sscanf( cp, "%d %d %d %d %d %d ", 
  1078.                         &atpar, &atchar, &left, &top, &right, &bottom);
  1079. #endif
  1080.             Nlm_LoadRect( &r, left, top, right, bottom);
  1081.             if (!fDocLink) fDocLink= new DocLink();
  1082.             fDocLink->SetLineRect(r, atpar, atchar);
  1083.             FindNextPlus(cp);
  1084.             }
  1085.  
  1086.         else if (0==Strncasecmp(cp, "+QUERYSTRING:",13)) { // dgg addition
  1087.             cp += 13;
  1088.             while (*cp && *cp <= ' ') cp++;
  1089.             if (*cp == '"') {
  1090.                 cp++; ep= cp;
  1091.                 while (*ep && *ep != '"') ep++;
  1092.                 }
  1093.             else if (*cp == '\'') {
  1094.                 cp++; ep= cp;
  1095.                 while (*ep && *ep != '\'') ep++;
  1096.                 }
  1097.             else {
  1098.                 ep= cp;
  1099.                 while (*ep && *ep > ' ') ep++;
  1100.                 }
  1101.             cep= *ep; *ep= 0;
  1102.             if (fQueryGiven) MemFree(fQueryGiven);
  1103.             fQueryGiven= StrDup(cp);
  1104.             *ep= cep;
  1105.             FindNextPlus(cp);
  1106.             }
  1107.             
  1108.         else if (0==Strncasecmp(cp, "+INFO:",6)) {
  1109.             cp += 6;
  1110.             // this probably means we messed up packaging plus data for this call
  1111.             // ?? should we exit/fail ??
  1112.             FindNextPlus(cp);
  1113.             } //+INFO
  1114.                         
  1115.         else {
  1116.             cp++;
  1117.             FindNextPlus(cp);
  1118.             } // +OTHER  +COMMENT
  1119.             
  1120.         cp= ep;    
  1121.         }            
  1122.  
  1123. #undef FindNextPlus    
  1124. }
  1125.  
  1126.  
  1127. void DGopher::SetLink( char ctype, const char* link)
  1128. {
  1129.     // link data expected is pointer to standard gopher info line:
  1130.     // 0Title<tab>path<tab>host<tab>port<tab>plus...etc...<null | cr-lf>
  1131.     char    *cp, *cp0;
  1132.  
  1133.     DeleteLink(true); // clean out any old link info
  1134.  
  1135.     fLinkLen= StrLen( link) + 1;
  1136.     fLink = (char*) MemDup( (void*)link, fLinkLen);
  1137.     cp= cp0= fLink;
  1138.     fType= ctype; //= *cp;  -- we may be overriding link type
  1139.     fItitle= 1; // title always starts at 2nd char in link
  1140.     cp= StringChr(cp, '\t'); if (cp) { *cp++= 0; fIpath= cp-cp0; } else fIpath= 0;
  1141.     cp= StringChr(cp, '\t'); if (cp) { *cp++= 0; fIhost= cp-cp0; } else fIhost= 0;
  1142.     cp= StringChr(cp, '\t'); if (cp) { *cp++= 0; fIport= cp-cp0; } else fIport= 0;
  1143.     cp= StringChr(cp, '\t'); if (cp) { *cp++= 0; fIplus= cp-cp0; } else fIplus= 0;
  1144.  
  1145.     fIsLocal= ( fIhost==0 
  1146.                             || StrICmp(fLink+fIhost,kLocalhost) == 0  
  1147.                             || StrICmp(fLink+fIhost,gEmptyString) == 0 );
  1148.     
  1149.     if (fIport) fPort= (short)atol( cp0 + fIport); else fPort= kGopherport; // ???
  1150.         
  1151.     // look for Date+Size in title as
  1152.     // "File listing  [14Apr92, 58kb]" is an example 
  1153.     cp= cp0 + fItitle;
  1154.     char *dp= StringRChr(cp, ']');
  1155.     if (dp) {
  1156.         char *sz= dp-3;
  1157.         if (isdigit(*sz) && sz[1] == 'k' && sz[2] == 'b') {
  1158.             char *db= StrRChr(cp, '[');
  1159.             if (db && db < dp) {
  1160.                 char *te= db-1; // terminate title
  1161.                 while (te > cp0 && isspace(*te)) te--;
  1162.                 *(te+1)= 0;
  1163.                 db++; //*db++= 0; 
  1164.                 fIdate= db - cp0;
  1165.                 while (isdigit(*sz)) sz--;
  1166.                 fIsize= sz+1 - cp0;
  1167.                 while (db<sz && *db!=',') db++;
  1168.                 *db= 0; // terminate date
  1169.                 *dp= 0; // terminate size
  1170.                 if (!fDateLong) { 
  1171.                     long yr = atol(cp0+fIdate+5); 
  1172.                     long day= atol(cp0+fIdate);
  1173.                     long mon= 0; 
  1174.                     while (mon<12 && strncmp(gMonths[mon], cp0+fIdate+2, 3) != 0) mon++;
  1175.                     fDateLong= 1900000000 + yr * 1000000 + mon * 10000
  1176.                                 + day * 100; 
  1177.                     }
  1178.                 if (!fSizeLong) {
  1179.                     fSizeLong= atol(cp0 + fIsize);
  1180.                     char snum[50];
  1181.                     if (fSizeLong) sprintf( snum, "%luk", fSizeLong);
  1182.                     else strcpy(snum,"<1k");
  1183.                     if (fDataSize) MemFree(fDataSize);
  1184.                     fDataSize= (char*) StrDup( snum);
  1185.                     }
  1186.                 }
  1187.             }
  1188.         }
  1189. }
  1190.  
  1191.  
  1192.  
  1193.  
  1194.  
  1195. void DGopher::ToText( CharPtr& h, short indent)
  1196. {    
  1197.     
  1198.     if (TRUE) { // if (fIsPlus) 
  1199.         char quote, *bufp, *buf, *plus;
  1200.             // RISKY having buf at fixed maxlen!, we need better way than sprintf(fixedbuf,...) !!
  1201.         long len= MAX( fLinkLen+1, 2048); 
  1202.         buf = (char*)MemNew(len);
  1203.         if (indent<0) indent= 0;
  1204.         if (indent) MemFill( buf, ' ', indent);
  1205.         bufp= buf+indent;
  1206.         
  1207.         if (fIsPlus) plus= "\t+"; else plus= "";
  1208.         sprintf( bufp, "+INFO: %c%s\t%s\t%s\t%d%s\n",
  1209.                 fType, (char*) GetName(), (char*) GetPath(), (char*) GetHost(), fPort, plus);
  1210.         StrExtendCat( &h, buf);
  1211.  
  1212.         if (fURL && fProtocol != kGopherprot) {
  1213.             //if (StrChr(fURL, '"')) quote= '\''; else quote= '"';
  1214.             quote= ' ';
  1215.             sprintf( bufp, "+URL: %c%s%c\n", quote,fURL,quote); 
  1216.             StrExtendCat( &h, buf);
  1217.             }
  1218.         
  1219.         // must store +MENU, +MENUSTRING, +QUERYSTRING and possibly other G+ block info
  1220.         // do we care to save +ADMIN, +VIEWS, +ASK, ... ???
  1221.  
  1222.         if (HasDocLink()) {
  1223.             short atparag, atchar;
  1224.             switch ( fDocLink->Kind()) {
  1225.                             
  1226.             case DocLink::kNoLink:
  1227.                 break;
  1228.                 
  1229.             case DocLink::kLine: {
  1230.                 short endparag, endchar;
  1231.                 fDocLink->GetLine( atparag, atchar, endparag, endchar);
  1232.                 sprintf( bufp, "+MENULINE: %d %d %d %d\n",
  1233.                                  atparag, atchar, endparag, endchar); 
  1234.                 StrExtendCat( &h, buf);
  1235.                 }
  1236.                 break;
  1237.  
  1238.             case DocLink::kLineRect: {
  1239.                 Nlm_RecT r;
  1240.                 fDocLink->GetLineRect( r, atparag, atchar);
  1241.                 sprintf( bufp, "+MENULINERECT: %d %d %d %d %d %d\n",
  1242.                                     atparag, atchar, r.left, r.top, r.right, r.bottom); 
  1243.                 StrExtendCat( &h, buf);
  1244.                 }
  1245.                 break;
  1246.  
  1247.             case DocLink::kRect: {
  1248.                 Nlm_RecT r;
  1249.                 fDocLink->GetRect( r);
  1250.                 sprintf( bufp, "+MENURECT: %d %d %d %d\n",
  1251.                                      r.left, r.top, r.right, r.bottom); 
  1252.                 StrExtendCat( &h, buf);
  1253.                 }
  1254.                 break;
  1255.                 
  1256.             case DocLink::kString: {
  1257.                 short skipval = 0;
  1258.                 char* links= fDocLink->GetString( skipval);
  1259.                 if (StrChr(links, '"')) quote= '\''; else quote= '"';
  1260.                 if (skipval)
  1261.                     sprintf( bufp, "+MENUSTRING: %c%s%c %d\n", quote, links, quote, skipval); 
  1262.                 else
  1263.                     sprintf( bufp, "+MENUSTRING: %c%s%c\n", quote,links,quote); 
  1264.                 StrExtendCat( &h, buf);
  1265.                 }
  1266.             break;
  1267.             
  1268.             }
  1269.     
  1270.         }
  1271.             
  1272.         if (fQueryGiven) {
  1273.             if (StrChr(fQueryGiven, '"')) quote= '\'';
  1274.             else quote= '"';
  1275.             sprintf( bufp, "+QUERYSTRING: %c%s%c\n", quote,fQueryGiven,quote); 
  1276.             StrExtendCat( &h, buf);
  1277.             }
  1278.             
  1279.         if (fGoMenuBlock) {
  1280.             // ...a bit of recursion...
  1281.             char* menutext= fGoMenuBlock->fGolist->WriteLinks(indent+1);
  1282.             sprintf(bufp, "+MENU:\n");
  1283.             StrExtendCat( &h, buf);
  1284.             StrExtendCat( &h, menutext);
  1285.             MemFree( menutext);
  1286.             }
  1287.  
  1288.         MemFree(buf);
  1289.         }
  1290.     else {
  1291.         char *buf = (char*)MemNew(fLinkLen+1);
  1292.         sprintf( buf, "%c%s\t%s\t%s\t%d\n",
  1293.                 fType, (char*) GetName(), (char*) GetPath(), (char*) GetHost(), fPort);
  1294.         StrExtendCat( &h, buf);
  1295.         MemFree(buf);
  1296.         }
  1297. }
  1298.  
  1299.  
  1300. void DGopher::ToServerText( CharPtr& h, short itemNum)
  1301. {
  1302.     long    maxlen= 7 * 6 + fLinkLen + 600; // is this safely more than we need?
  1303.     char     *buf= new char[ maxlen];
  1304.     char    *cp= buf;
  1305.     char  quote, cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1306.     char*    stmp;
  1307.         
  1308.     sprintf( cp, "Name=%s%s", (char*) GetName(),LineEnd); cp += strlen(cp);  
  1309.     if (itemNum) { sprintf( cp, "Numb=%d%s", itemNum,LineEnd); cp += strlen(cp); }
  1310.     sprintf( cp, "Type=%c%c%s", fType, cplus,LineEnd); cp += strlen(cp);
  1311.     sprintf( cp, "Host=%s%s", (char*) GetHost(),LineEnd);  cp += strlen(cp);  
  1312.     sprintf( cp, "Port=%d%s", fPort,LineEnd); cp += strlen(cp);
  1313.     sprintf( cp, "Path=%s%s", (char*) GetPath(),LineEnd); cp += strlen(cp);
  1314.     StrExtendCat( &h, buf);
  1315.     
  1316.     if (fAdminEmail) { 
  1317.         sprintf( buf, "Admin=%s%s", fAdminEmail,LineEnd);  
  1318.         StrExtendCat( &h, buf);
  1319.         }
  1320.     stmp= (char*)GetDate(); 
  1321.     if (stmp && *stmp) {
  1322.         sprintf(buf, "#+Mod-Date:%s%s", stmp,LineEnd);
  1323.         StrExtendCat( &h, buf);
  1324.         }
  1325.  
  1326.     if (fURL) {
  1327.         //if (StrChr(fURL, '"')) quote= '\''; else quote= '"';
  1328.         quote= ' ';
  1329.         sprintf( buf, "+URL: %c%s%c\n", quote,fURL,quote); 
  1330.         StrExtendCat( &h, buf);
  1331.         }
  1332.  
  1333. #if 0
  1334.     if (fIsPlus == kGopherPlusYes) {
  1335.         sprintf( buf, "#+Views:%s",LineEnd);
  1336.         StrExtendCat( &h, buf);
  1337.         CArrayIterator iter( fViews);
  1338.         void*     iview;
  1339.         for (iview = iter.First(); iter.More(); iview = iter.Next())  {
  1340.             stmp= (*(DGopherItemView**) iview)->ViewVal();
  1341.             sprintf( buf, "# %s%s",  (char*)stmp,LineEnd);
  1342.             StrExtendCat( &h, buf);
  1343.             }
  1344.         }
  1345. #endif
  1346.  
  1347.     sprintf( buf, "#%s",LineEnd); 
  1348.     StrExtendCat( &h, buf);
  1349.     delete[] buf;
  1350. }
  1351.  
  1352.  
  1353.  
  1354. void DGopher::ToPrettyText( CharPtr& h, short /*itemNum*/,
  1355.                 Boolean showDate, Boolean showSize, Boolean showKind, Boolean showPath, 
  1356.                 Boolean showHost, Boolean showPort, Boolean showAdmin)
  1357. {
  1358.     char*    stmp;
  1359.     long    maxlen= 8 * 6 + fLinkLen + 600; // is this safely more than we need?
  1360.     char     *buf= new char[ maxlen];
  1361.     char    *cp= buf;
  1362.     char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1363.     
  1364. #define SprintIfReal(WHAT)    \
  1365.     if (stmp && *stmp) sprintf( cp, "\t%s", stmp); else sprintf( cp, "\t"); \
  1366.     cp += strlen(cp);     
  1367.     
  1368.     stmp= (char*)GetName(); sprintf( cp, "%s", stmp); cp += strlen(cp); 
  1369.     if (showDate) { stmp= (char*)GetDate(); SprintIfReal("Date"); }
  1370.     if (showSize) { stmp= (char*)GetDataSize(); SprintIfReal("Size"); }
  1371.     if (showKind) { sprintf( cp, "\t%c%c", fType, cplus); cp += strlen(cp); }
  1372.     if (showPath) { stmp= (char*)GetPath(); SprintIfReal("Path"); }
  1373.     if (showHost) { stmp= (char*)GetHost(); SprintIfReal("Host"); }
  1374.     if (showPort) { sprintf( cp, "\t%d", fPort); cp += strlen(cp); }
  1375.     if (showAdmin && fAdminEmail) { stmp= fAdminEmail; SprintIfReal("Admin"); }
  1376.     sprintf( cp, "%s",LineEnd); cp += strlen(cp);
  1377.     StrExtendCat( &h, buf);
  1378.     
  1379.     delete[] buf;
  1380. }
  1381.  
  1382. void DGopher::StoreName(char* aStr)
  1383. {
  1384.     long len= 100 + fLinkLen + StrLen(aStr);
  1385.     char *link = (char*) MemNew(len);
  1386.     char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1387.     sprintf( link, "%c%s\t%s\t%s\t%d\t%c",
  1388.         fType, aStr/*(char*) GetName()*/, (char*) GetPath(), (char*) GetHost(), fPort, cplus);
  1389.     SetLink( fType, link);
  1390.     MemFree( link);
  1391. }
  1392.  
  1393. void DGopher::StorePath(char* aStr)
  1394. {
  1395.     long len= 100 + fLinkLen + StrLen(aStr);
  1396.     char *link = (char*) MemNew(len);
  1397.     char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1398.     sprintf( link, "%c%s\t%s\t%s\t%d\t%c",
  1399.         fType, (char*) GetName(), aStr/*(char*) GetPath()*/, (char*) GetHost(), fPort, cplus);
  1400.  
  1401.     SetLink( fType, link);
  1402.     MemFree( link);
  1403. }
  1404.  
  1405. void DGopher::StoreHost(char* aStr)
  1406. {
  1407.     long len= 100 + fLinkLen + StrLen(aStr);
  1408.     char *link = (char*) MemNew(len);
  1409.     char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1410.     if (!aStr || !*aStr || StrICmp(aStr,gEmptyString) == 0) 
  1411.         aStr= (char*)kLocalhost;
  1412.     sprintf( link, "%c%s\t%s\t%s\t%d\t%c",
  1413.         fType, (char*) GetName(), (char*) GetPath(), aStr/*(char*) GetHost()*/, fPort, cplus);
  1414.     SetLink( fType, link);
  1415.     MemFree( link);
  1416.     // done in SetLink: fIsLocal= (StrICmp(aStr,kLocalhost) == 0 ); // fProtocol == kFileprot && 
  1417. }
  1418.  
  1419. void DGopher::StorePort(char* aStr)
  1420. {
  1421.     long len= 100 + fLinkLen + StrLen(aStr);
  1422.     char *link = (char*) MemNew(len);
  1423.     char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1424.     sprintf( link, "%c%s\t%s\t%s\t%s\t%c",
  1425.         fType, (char*) GetName(), (char*) GetPath(), (char*) GetHost(), aStr/*fPort*/, cplus);
  1426.     SetLink( fType, link);
  1427.     MemFree( link);
  1428. }
  1429.  
  1430.  
  1431. // static
  1432. short DGopher::StandardPort( short protocol)
  1433. {
  1434.     switch (protocol) {
  1435.         case kGopherprot: return kGopherport;
  1436.         case kHTTPprot    : return kHTTPport;
  1437.         case kSMTPprot    :    return kSMTPport;
  1438.         case kFileprot    : return kFileport;
  1439.         case kFTPprot        : return kFTPport;
  1440.         case kTelnetprot: return kTelnetport;
  1441.         case kTN3270prot: return kTN3270port;
  1442.         case kWhoisprot    : return kWhoisport;
  1443.         case kFingerprot: return kFingerport;
  1444.         case kPOPprot        : return kPOPport;
  1445.         case kNNTPprot    : return kNNTPport;
  1446.         case kWAISprot    : return kWAISport;
  1447.  
  1448.         case kUnsupportedProt: return kUnsupportedPort;
  1449.         default:
  1450.         case kUnknownProt: return kUnknownPort;
  1451.         }
  1452. }
  1453.  
  1454. void DGopher::StoreProtocol( short protocol)
  1455. {
  1456.     fProtocol= protocol;
  1457.     fPort= StandardPort( fProtocol);
  1458.     switch (fProtocol) {    
  1459.             
  1460.         case  kGopherprot    :  
  1461.         case  kHTTPprot        :  
  1462.         case  kFTPprot        : 
  1463.         case  kFileprot        : 
  1464.             // need to flag if localhost !? -- for all prots ??
  1465.             fIsLocal= (StrICmp(GetHost(),kLocalhost) == 0 
  1466.                             || StrICmp(GetHost(),gEmptyString) == 0 );
  1467.             break;
  1468.             
  1469.             // currently unsupported
  1470.         case  kNNTPprot        : 
  1471.         case  kWAISprot        :  
  1472.         case  kTelnetprot    :  
  1473.         case  kTN3270prot    : 
  1474.         case  kUnknownProt:
  1475.         case  kUnsupportedProt:
  1476.             fType= kTypeError; // ??
  1477.             break;
  1478.         }
  1479. }
  1480.  
  1481.  
  1482. const char* DGopher::GetProtocol()
  1483. {
  1484. #if 0
  1485.     short item= DGopher::GetProtoItem(fProtocol);
  1486.     if (item<0) return "unknown://";
  1487.     return DGopher::GetProtoName(item);
  1488. #else
  1489.     switch (fProtocol) {
  1490.         case  kNNTPprot        : return "news:"; 
  1491.         case  kSMTPprot        : return "mailto:"; 
  1492.         case  kGopherprot    : return "gopher://"; 
  1493.         case  kHTTPprot        : return "http://"; 
  1494.         case  kFTPprot        : return "ftp://";  // should be same as file:// ??
  1495.         case  kFileprot        : return "file://"; 
  1496.         case  kWAISprot        : return "wais://"; 
  1497.         case  kTelnetprot    : return "telnet://"; 
  1498.         case  kTN3270prot    : return "tn3270://"; 
  1499.         
  1500.         case  kUnknownProt: 
  1501.         case  kUnsupportedProt: 
  1502.         default: 
  1503.                 return "unknown://";                
  1504.         }
  1505. #endif
  1506. }
  1507.  
  1508. void DGopher::StoreURL(char* aStr)
  1509. {
  1510.     fURL= (char*) MemFree(fURL); 
  1511.     if (aStr) fURL= StrDup(aStr);
  1512. }
  1513.  
  1514. const char* DGopher::GetURL()
  1515. {
  1516. //    sprintf( buf, "URL: gopher://%s:%d/%c/%s%s", 
  1517. //                    (char*) GetHost(), fPort, fType, (char*) GetPath(),LineEnd);
  1518.     if (!fURL) {
  1519.         char cstore[512];
  1520.         char* url= StrDup( GetProtocol());
  1521.         StrExtendCat( &url, (char*) GetHost());
  1522.         if (fPort != StandardPort(fProtocol)) {
  1523.             sprintf( cstore, ":%d", fPort);
  1524.             StrExtendCat( &url, cstore);
  1525.             }
  1526.         
  1527.         char* epath= DURL::EncodeChars( GetPath());
  1528.         switch (fProtocol) {
  1529.             case kGopherprot:
  1530.                 sprintf( cstore, "/%c%s", fType,epath);
  1531.                 StrExtendCat( &url, cstore);
  1532.                 break;
  1533.                 
  1534.              case kFileprot:
  1535.                 if (*epath != '/') {
  1536.                     StrExtendCat( &url, "/");
  1537.                     // ?? do some fiddling w/ *path ???
  1538.                     }
  1539.             default:
  1540.                 StrExtendCat( &url, epath);
  1541.                 break;
  1542.             }
  1543.             
  1544.         MemFree( epath);
  1545.         
  1546.         if (fQueryGiven) {
  1547.             StrExtendCat( &url, "?");
  1548.             StrExtendCat( &url, fQueryGiven);
  1549.             }
  1550.             
  1551.         fURL= url;
  1552.         }
  1553.     return fURL;
  1554. }
  1555.  
  1556.  
  1557. void DGopher::StorePlus(char *plus)
  1558. {
  1559.     long len= 10 + fLinkLen + 1;
  1560.     char *link = (char*) MemNew(len);
  1561.     //char cplus = (fIsPlus == kGopherPlusYes) ? '+' : ' ';
  1562.     sprintf( link, "%c%s\t%s\t%s\t%d\t%c",
  1563.         fType, (char*) GetName(), (char*) GetPath(), (char*) GetHost(), fPort, *plus);
  1564.     SetLink( fType, link);
  1565.     MemFree( link);
  1566. }
  1567.  
  1568. void DGopher::StorePlus(Boolean isplus)
  1569. {
  1570.     if (isplus) { 
  1571.         fIsPlus = kGopherPlusYes; 
  1572.         StorePlus("+");
  1573.         }
  1574.     else { 
  1575.         fIsPlus = kGopherPlusNo; 
  1576.         StorePlus("");
  1577.         }
  1578. }
  1579.  
  1580.  
  1581.  
  1582. Boolean DGopher::Edit(long dialogID)
  1583. {
  1584.     Boolean            result= false;
  1585.  
  1586.     DGopherEditWindow *aWind= new DGopherEditWindow(this, dialogID != 0);
  1587.     result= aWind->PoseModally();
  1588.     delete aWind;
  1589.     // aWind handles all of rest -- okay button causes this gopher to be updated
  1590.     
  1591.     return result;
  1592. }
  1593.  
  1594.  
  1595. Boolean DGopher::Equals(DGopher* other)
  1596. {
  1597.     if (!other) return false;
  1598.     else if (fType != other->fType) return false;
  1599.     else if (fPort != other->fPort) return false;
  1600.     else if (fProtocol != other->fProtocol) return false;
  1601.     else if (StringCmp( fLink+fIhost, other->fLink+other->fIhost)) return false;
  1602.     else if (StringCmp( fLink+fIpath, other->fLink+other->fIpath)) return false;
  1603.     else if (StringCmp( fQueryGiven, other->fQueryGiven)) return false;
  1604.     else return true;
  1605. }
  1606.  
  1607. Boolean DGopher::operator ==(DGopher* other)
  1608. {
  1609.     return Equals(other);
  1610. }
  1611.             
  1612.  
  1613. void DGopher::SwapPathType(char oldtype, char newtype)
  1614. {
  1615.     // this is very risky as protocol says path is opaque to client -- should drop.
  1616.     // want it to set binary/text transfer protocol for server
  1617.     if (*(fLink+fIpath) == oldtype) *(fLink+fIpath)= newtype;
  1618. }
  1619.  
  1620.  
  1621. void DGopher::SetOwner( DGopherList* OwnerList)  
  1622. {
  1623.     fOwnerList= OwnerList;
  1624.     if (fOwnerList) fStatusLine= fOwnerList->fStatusLine; // ?? is this only use of fOwnerList?
  1625.     gNeedTypeChange= false;
  1626.     
  1627.     if (gDoSuffix2MacMap && gGopherMap) {
  1628.         DGopherMap* mapper;
  1629.         mapper= gGopherMap->MatchGopherType( this);
  1630.         if (mapper) gNeedTypeChange |= mapper->Map(this);
  1631.         mapper= gGopherMap->MatchSuffix( this);
  1632.         if (mapper) gNeedTypeChange |= mapper->Map(this);
  1633.         }
  1634. }
  1635.  
  1636.  
  1637.  
  1638. const char* DGopher::GetKindName() 
  1639. { 
  1640.     return "Unknown"; 
  1641. }
  1642.  
  1643. const char* DGopher::GetName()   
  1644. {
  1645.     if (fItitle) return  fLink + fItitle;
  1646.     else return gEmptyString;
  1647. }
  1648.  
  1649. const char* DGopher::GetDate()   
  1650. {
  1651.     if (fDate) return fDate;
  1652.     else if (fIdate) return  fLink + fIdate;
  1653.     else return gEmptyString;
  1654. }
  1655.  
  1656. const char* DGopher::GetDataSize()   
  1657. {
  1658.     if (fDataSize) return fDataSize;
  1659.     else if (fIsize) return fLink + fIsize;
  1660.     else return gEmptyString;
  1661. }
  1662.  
  1663. const char* DGopher::GetPath()   
  1664. {
  1665.     if (fIpath) return fLink + fIpath;
  1666.     else return gEmptyString;
  1667. }
  1668.  
  1669. const char* DGopher::GetHost()   
  1670. {
  1671.     if (fIhost) return fLink + fIhost;
  1672.     else return gEmptyString;
  1673. }
  1674.  
  1675. const char* DGopher::GetPort()   
  1676. {
  1677.     if (fIport) return fLink + fIport;
  1678.     else return gEmptyString;
  1679. }
  1680.  
  1681. const char* DGopher::GetPlus()   
  1682. {
  1683.     if (fIplus) return fLink + fIplus;
  1684.     else return gEmptyString;
  1685. }
  1686.  
  1687.  
  1688. const char* DGopher::ShortName()   
  1689. {
  1690.     static char  shorty[33];
  1691.     if (fItitle) {
  1692.         strncpy(shorty, fLink + fItitle, 32);
  1693.         shorty[33]= 0;
  1694.         return shorty;
  1695.         }
  1696.     else return gEmptyString;
  1697. }
  1698.  
  1699. void DGopher::ReadALine() 
  1700. // this is here for easy subclassing to process line as read thru talker 
  1701. {
  1702.     char *data = NULL;
  1703.  
  1704.     if (fIsLocal && fReplyFile) {
  1705.         char dline[1024];
  1706.         ulong datalen= 1024;
  1707.         fReplyFile->ReadLine( dline, datalen);
  1708.         if (datalen>0) {
  1709.             dline[datalen]= 0;
  1710.             if (fInfo == NULL) {
  1711.                 fInfo= (char*)MemDup(dline, datalen+1);
  1712.                 fInfoSize= datalen;
  1713.                 }
  1714.             else {
  1715.                 MemExtendCat( &fInfo, fInfoSize, dline, datalen+1); // +1 for 0
  1716.                 fInfoSize += datalen;
  1717.                 }
  1718.             }
  1719.  
  1720.         }
  1721.     else if (fTalker && fTalker->ReadALine( NULL, data)) {
  1722.                                 // this changes w/ subclasses...
  1723.         if ( data[0] == '.' && data[1] == kCR ) 
  1724.             fTalker->SetEndOfMessage(true);
  1725.         if (!fTalker->EndOfMessage()) {
  1726.             long datalen= StrLen(data);
  1727.             if (fInfo == NULL) {
  1728.                 fInfo= data;
  1729.                 fInfoSize= datalen;
  1730.                 }
  1731.             else {
  1732.                 MemExtendCat( &fInfo, fInfoSize, data, datalen+1); // +1 for 0
  1733.                 fInfoSize += datalen;
  1734.                 MemFree( data);
  1735.                 }
  1736.             }
  1737.         }
  1738. }
  1739.  
  1740.  
  1741. Boolean DGopher::EndOfMessage()
  1742. // this is here for easy subclassing to process line as read thru talker 
  1743. {
  1744.     return fTalker->EndOfMessage();
  1745. }
  1746.  
  1747.  
  1748.  
  1749. void DGopher::ShowMessage(const char* msg)
  1750. {
  1751.     if (fStatusLine) fStatusLine->SetTitle( (char*)msg);
  1752. }
  1753.  
  1754. void DGopher::ShowProgress()
  1755. {
  1756.     char snum[40], buf[128];
  1757.     Dgg_LongToStr( fBytesReceived, snum, 0, 40);
  1758.     sprintf( buf, "Bytes sent: %s", snum);
  1759.     long csec = fConnectTime; // time / 60;
  1760.     if (csec > 0) {
  1761.         char buf2[128];
  1762.         csec= fBytesReceived / csec;
  1763.         Dgg_LongToStr( csec, snum, 0, 40);
  1764.         sprintf( buf2, "%s, bytes/sec: %s", buf, snum);
  1765.         ShowMessage( buf2);
  1766.         }
  1767.     else
  1768.         ShowMessage( buf);
  1769. }
  1770.  
  1771.  
  1772.  
  1773. void DGopher::FinishRead()
  1774. {
  1775. }
  1776.  
  1777. const char* DGopher::GetViewChoiceKind()
  1778. {
  1779.     if (fViewchoice > 0 && fViews && (fViews->GetSize()>0)) {
  1780.         DGopherItemView* giv= (DGopherItemView*) fViews->At(fViewchoice-1);
  1781.         if (giv) return giv->Kind();
  1782.         }
  1783.     return NULL; // or use gGopherMap & fType to return default Kind ??
  1784. }
  1785.  
  1786. void DGopher::CheckViewMappers()
  1787. {
  1788.     if (fViews) {        
  1789.         DGopherItemView* giv;
  1790.         unsigned short maxrank= 0;
  1791.         long i, maxat= 0, nviews= fViews->GetSize();
  1792.         char* cp;
  1793.         for (i= 0; i<nviews; i++) {
  1794.             char * viewkind;
  1795.             unsigned short lastrank = 0; 
  1796.             giv= (DGopherItemView*) fViews->At(i);
  1797.             viewkind= (char*)giv->Kind();
  1798.             DGopherMap* aMapper= gGopherMap->MatchHandlerKind( lastrank, viewkind); 
  1799.             if (aMapper) {
  1800.                 giv->fViewStatus= lastrank;
  1801.                 if (lastrank > maxrank) { maxrank= lastrank; maxat= i; }
  1802.                 }
  1803.             else
  1804.                 giv->fViewStatus= DGopherItemView::kUnknownStatus;
  1805.             }
  1806.         giv= (DGopherItemView*) fViews->At(maxat);
  1807.         giv->fViewStatus= DGopherItemView::kMaxStatus;
  1808.         if (maxrank>0) fViewchoice= maxat + 1; //???
  1809.         }
  1810. }
  1811.  
  1812.  
  1813.  
  1814. #if 0
  1815.  
  1816. // LocalGopher.....
  1817.  
  1818. types of calls to handle locally:
  1819.  
  1820.     for all calls
  1821.         x-- if StrChr( GetPath(), '/') && !defined(OS_UNIX)
  1822.            do filesystem path translation
  1823.         x-- must tack on gGopherRoot to top of path ??
  1824.         
  1825.   for any app call
  1826.       x-- add -v view/choice cmdline param ?
  1827.   
  1828.   if (path == "R123-456-path/to/data")
  1829.       x-- handle data file subrange
  1830.       
  1831.     if (fType == kTypeFolder) 
  1832.         || StrICmp( viewchoice,"application/gopher-menu") == 0
  1833.         || StrICmp( viewchoice,"application/gopher+-menu")==0
  1834.         )
  1835.         -- do local-filesystem directory to gopher menu translation
  1836.         -- some of these types may be to call apps instead (exec+, ?query)
  1837.         
  1838.   if (fQuery) 
  1839.       -- assume path is to local executable? 
  1840.       x-- may be path wais index.{src,dct,inv} instead !?
  1841.          ?? can we handle this with call to apps/askwais -d path/to/index ??
  1842.       x-- call DChildApp::Launch() w/ fQuery part of cmdline
  1843.       
  1844.   if (fType == kTypeQuery)
  1845.       x-- assume path is to local executable? 
  1846.       x-- may be path wais index.{src,dct,inv} instead !?
  1847.         -- should always have (fQuery) ?
  1848.  
  1849.     else if (fTypes == othertype)
  1850.          
  1851.          kTypeFile -- read & display local file 
  1852.          kTypeBinary 
  1853.          kTypeSound  
  1854.          kTypeImage 
  1855.          kTypeMovie 
  1856.          kTypeGif         
  1857.          kTypeHtml   
  1858.          others -- no special handling
  1859.  
  1860.   if (StrNICmp( GetPath(), "exec+:", 6)==0)  
  1861.       x-- assume path is to local executable
  1862.       x-- cut cmdline params from exec+:params:/path/to/app
  1863.       x-- call DChildApp::Launch()  
  1864.       
  1865.   if (fQueryPlus)
  1866.       -- this is typically either "\t+" or "\t$" or "\t!" or esp. fReplyData
  1867.     -- this is of low importance?
  1868.     
  1869.   if (fHaveReply) // for ASK forms, 
  1870.       x-- see fQueryPlus, but also may have fReplyFile
  1871.       x-- assume path is to app, call DChildApp::Launch()
  1872.    
  1873. #endif
  1874.  
  1875.  
  1876.  
  1877.  
  1878.   
  1879. void DGopher::LocalQuery( char* viewchoice)
  1880. {
  1881.     enum actions { kDoNothing, kShowFile, kShowFileSection, kShowFolder, 
  1882.                                 kLaunchApp, kLaunchWais };
  1883.     short action = kDoNothing, kind;
  1884.     char * Stdinbuf = NULL, * Stdinfile= NULL;
  1885.     char * pathname = StrDup( (char*) GetPath()); 
  1886.     char * cmdline  = StrDup("");
  1887.     char * shortpath = pathname, * thepath= pathname;
  1888.     long     rootlen= 0;
  1889.     char * cp, * dp;
  1890.     long   rstart = 0, rend = 0;
  1891.     ulong filelen = 0;
  1892.     
  1893.      fTalker= NULL;
  1894.     fBytesExpected= 0; //kReadToClose;
  1895.     fBytesReceived= 0;
  1896.     fConnectTime= 0;
  1897.  
  1898.     if (!viewchoice && (fType == kTypeHtml || fProtocol == kHTTPprot)) {
  1899.         viewchoice= "text/html";
  1900.         }
  1901.  
  1902.     if (viewchoice) {
  1903.         StrExtendCat( &cmdline, " -v ");
  1904.         StrExtendCat( &cmdline, viewchoice);
  1905.         }
  1906.  
  1907.   if (StrNICmp( pathname, "exec+:", 6)==0) {
  1908.       char * cmds, * ep;
  1909.       cmds= pathname+6;
  1910.       ep= StrChr( cmds, ':');
  1911.       if (ep) {
  1912.           *ep++= 0;
  1913.             StrExtendCat( &cmdline, " ");
  1914.              // ! this is risky, but how else do we handle paths in the cmdline ??
  1915.             DFileManager::UnixToLocalPath( cmds); 
  1916.           StrExtendCat( &cmdline, cmds);
  1917.           Nlm_MemMove( pathname, ep, 1+StrLen(ep));
  1918.           }
  1919.         action= kLaunchApp;     
  1920.         }
  1921.     else if (*pathname == 'R' 
  1922.         && isdigit(pathname[1])
  1923.         && (cp= StrChr(pathname, '-')) != NULL
  1924.         && isdigit(cp[1])
  1925.         && (dp= StrChr(cp+1, '-')) > cp ) { 
  1926.             //handle doc subrange paths like 'R851270-852774-:Flybase:genes:genes.txt'
  1927.             rstart= atol( pathname+1);
  1928.             rend  = atol( cp+1);
  1929.             dp++;
  1930.           Nlm_MemMove( pathname, dp, 1+StrLen(dp));
  1931.             action= kShowFileSection;
  1932.             }
  1933.         
  1934. #if 0
  1935.   else if (StrNICmp( pathname, "waissrc:", 6)==0) {
  1936.         // ?? kLaunchWais on local wais src ??
  1937.         }
  1938. #endif        
  1939.  
  1940.     kind= DFileManager::FileOrFolderExists( pathname);
  1941.     if (kind==0) {
  1942.         DFileManager::UnixToLocalPath( pathname);
  1943.         kind= DFileManager::FileOrFolderExists( pathname);
  1944.         if (kind==0) {
  1945.             StrPrependCat( &pathname, gLocalGopherRoot);
  1946.             rootlen= StrLen(gLocalGopherRoot);
  1947.             shortpath= pathname + rootlen;
  1948.             thepath= pathname;
  1949.             kind= DFileManager::FileOrFolderExists( pathname);
  1950.             }
  1951.         }
  1952.     
  1953.     if (kind == DFileManager::kIsFolder) {
  1954.         fType= kTypeFolder; // ??
  1955.         action= kShowFolder;
  1956.         }    
  1957.         
  1958.     if (action == kDoNothing && fType == kTypeQuery && fQuery) {
  1959.         if ( DFileManager::FileExists(pathname) )
  1960.             action= kLaunchApp;
  1961.         else if ( DFileManager::FileExists(shortpath) ) {
  1962.             thepath= shortpath;
  1963.             action= kLaunchApp;
  1964.             }
  1965.         else {
  1966.             char path2[512];
  1967.             StrNCpy( path2, pathname, sizeof(path2));
  1968.             StrNCat( path2, ".src", sizeof(path2));
  1969.             if (DFileManager::FileExists( path2)) {
  1970.                 action= kLaunchWais;
  1971.                 // add default cmdline for AskWais...
  1972. #if 1
  1973.                 sprintf( path2, " -+i -d %s", pathname);
  1974. #else
  1975.                 sprintf( path2, " -+i -g %s -d %s", gLocalGopherRoot, pathname);
  1976. #endif
  1977.                 StrExtendCat( &cmdline, path2); 
  1978.                 }
  1979.             else if (DFileManager::FileExists( path2+rootlen)) {
  1980.                 action= kLaunchWais;
  1981. #if 1
  1982.                 sprintf( path2, " -+i -d %s", shortpath);
  1983. #else
  1984.                 sprintf( path2, " -+i -g %s -d %s", gLocalGopherRoot, shortpath);
  1985. #endif
  1986.                 StrExtendCat( &cmdline, path2); 
  1987.                 }
  1988.             }
  1989.         }
  1990.  
  1991.     if (fHasAsk && fHaveReply) {
  1992.         action= kLaunchApp;     
  1993.         if (fQueryPlus) Stdinbuf= fQueryPlus;
  1994.         else if (fReplyFile) Stdinfile= (char*) fReplyFile->GetName();
  1995.          }
  1996.     else if (fQueryPlus) {
  1997.         // typically either "\t+" or "\t$" or  "\t!"
  1998.         }
  1999.  
  2000.     if (fQuery) {
  2001.         *fQuery= ' '; // note: *fQuery == '\t', change to blank for cmdline
  2002.         StrExtendCat( &cmdline, " ");
  2003.         StrExtendCat( &cmdline, fQuery);
  2004.         if (action == kDoNothing) action= kLaunchApp; //?? is just fQuery enough to act this way?
  2005.         }
  2006.     
  2007.     if (action == kDoNothing)  switch (fType) {
  2008.         case kTypeFile  :  
  2009.         case kTypeBinary:  
  2010.         case kTypeSound :  
  2011.         case kTypeImage : 
  2012.         case kTypeMovie : 
  2013.         case kTypeGif        :  
  2014.         case kTypeHtml  :
  2015.             action= kShowFile; 
  2016.             break;  
  2017.         case kTypeFolder  :
  2018.             action= kShowFolder; 
  2019.             // ?? some subcall if fQueryPlus == $ or + or ! ??
  2020.             break;  
  2021.         }
  2022.  
  2023. #if 0
  2024.     // ???
  2025.     if (action == kDoNothing && ( viewchoice && 
  2026.         (StrICmp( viewchoice,"application/gopher-menu")==0
  2027.         || StrICmp( viewchoice,"application/gopher+-menu")==0 )
  2028.         ) ) {
  2029.         action= kShowFolder;
  2030.         }
  2031. #endif
  2032.  
  2033.     if (fQueryPlus && StrCmp(fQueryPlus,"\t!")==0) {
  2034.             // drop info calls for now ?
  2035.         action= kDoNothing;
  2036.         }
  2037.         
  2038.     switch (action) {
  2039.             
  2040.         case kShowFileSection: {
  2041.             fReplyFile= new DFile( thepath, "rb"); // don't forget "b" binary, or will fail w/ newline translation for bin files !!
  2042.           fReplyFile->Open("rb");
  2043.             //fReplyFile->GetDataLength(filelen); 
  2044.             fReplyFile->Seek( rstart);
  2045.             fBytesExpected= rend - rstart + 1; // ?? +1 ??  
  2046.             }
  2047.             break;
  2048.  
  2049.         case kShowFile: {
  2050.             fReplyFile= new DFile( thepath, "rb"); // don't forget "b" binary, or will fail w/ newline translation for bin files !!
  2051.           fReplyFile->Open("rb");
  2052.             fReplyFile->GetDataLength(filelen); 
  2053.             fBytesExpected= filelen;  
  2054.             }
  2055.             break;
  2056.             
  2057.         case kShowFolder: {
  2058. #if 0
  2059.     //debug
  2060. #include <DApplication.h>
  2061.             char* stdoutfile= StrDup("Gopup.localfolder");
  2062.             StrPrependCat( &stdoutfile, 
  2063.                 (char*)DFileManager::PathOnlyFromPath( gApplication->Pathname()));
  2064.             fReplyFile= new DFile(stdoutfile);  
  2065. #else
  2066.             fReplyFile= new DTempFile(); // disk file will be removed on delete
  2067. #endif
  2068.           fReplyFile->Open("w");
  2069.             DGopherList::LocalFolder2GopherList( fReplyFile, thepath);
  2070.           fReplyFile->Open("r");
  2071.             fReplyFile->GetDataLength(filelen); 
  2072.             fBytesExpected= filelen;  
  2073.             }
  2074.             break;
  2075.             
  2076.         case kLaunchApp: {
  2077.             DChildApp* child= new DChildApp( thepath, cmdline, true, Stdinfile, true); 
  2078.             if (Stdinbuf) 
  2079.                 child->AddInputBuffer( DChildFile::kStdin, Stdinbuf, StrLen(Stdinbuf));
  2080.             if (!child->Launch())
  2081.                 Message(MSG_OK, "Failed to launch %s with '%s'", thepath, cmdline);
  2082.             }
  2083.             break;
  2084.             
  2085.         case kLaunchWais: {
  2086.             if (DFileManager::FileExists( gAskWaisPath))
  2087.                 thepath= gAskWaisPath;
  2088.             else {
  2089.                 MemFree( pathname);
  2090.               pathname= StrDup( gLocalGopherRoot);
  2091.                 StrExtendCat( &pathname, gAskWaisPath );
  2092.                 thepath= pathname;
  2093.                 }
  2094. #if 0
  2095.     // debugging
  2096. #include <DApplication.h>
  2097.             char* stdoutfile= StrDup("Gopup.stdout");
  2098.             StrPrependCat( &stdoutfile, 
  2099.                 (char*)DFileManager::PathOnlyFromPath( gApplication->Pathname()));
  2100.             DChildApp* child= new DChildApp( thepath, cmdline, false, NULL, true); 
  2101.             DChildFile* cfile= new DChildFile( stdoutfile, DChildFile::kStdout,
  2102.                                         DChildFile::kDontDelete, DChildFile::kOpenText, "w");
  2103.             child->AddFile(cfile);
  2104.             MemFree(stdoutfile);
  2105. #else
  2106.             DChildApp* child= new DChildApp( thepath, cmdline, true, NULL, true); 
  2107. #endif
  2108.             if (!child->Launch())
  2109.                 Message(MSG_OK, "Failed to launch %s with '%s'", thepath, cmdline);
  2110.             }
  2111.             break;
  2112.             
  2113.         case kDoNothing:
  2114.         default:
  2115.             fBytesExpected= 0;
  2116.             break;
  2117.         }
  2118.                 
  2119.     fQueryPlus= NULL; // set to zero after each call?
  2120.     fQuery= NULL;
  2121.  
  2122.     MemFree( pathname);
  2123.     MemFree( cmdline);
  2124. }
  2125.  
  2126.  
  2127.  
  2128.  
  2129. void DGopher::OpenQuery()
  2130. {
  2131.     char* viewchoiceptr = NULL;
  2132.     char    viewchoicestore[256];
  2133.     
  2134.     if (fViewchoice > 0)
  2135.      if (fViews && fViews->GetSize()>1) {
  2136.         DGopherItemView* giv= (DGopherItemView*) fViews->At(fViewchoice-1);
  2137.         if (giv) {
  2138.             strcpy( viewchoicestore, giv->ViewRequest());
  2139.             viewchoiceptr= viewchoicestore;
  2140.             if (fQueryPlus && (0 == StrCmp(fQueryPlus,"\t+") || 0 == StrCmp(fQueryPlus,"\t$")))
  2141.                 fQueryPlus= NULL; // !! fix bug of sending <tab>+ after <tab>+viewchoice !!
  2142.             }
  2143.         }
  2144.         
  2145.     DeleteInfo();
  2146.     
  2147.     fThreadState= kThreadStarted;
  2148.     if (fIsLocal) {
  2149.         LocalQuery( viewchoiceptr);
  2150.         return;
  2151.         }
  2152.  
  2153.     fTalker= new DGopherTalk();  
  2154.     switch (fProtocol) {
  2155.  
  2156.         case kFingerprot: 
  2157.         case kWhoisprot: 
  2158.         case kGopherprot:
  2159.             fTalker->OpenQuery( fLink+fIhost, fPort, fLink+fIpath, fQuery, 
  2160.                                             viewchoiceptr, fQueryPlus, (fHaveReply)?fReplyFile:NULL);
  2161.             break;
  2162.  
  2163.         case kHTTPprot: {
  2164.             char * postdata = NULL;
  2165.             char * httppath= DURL::EncodeChars( GetPath());  // ?? possible double-encoding?
  2166.             StrPrependCat( &httppath, "GET ");
  2167.             if (fQuery) {
  2168.                 *fQuery= '?'; // note: *fQuery == '\t', change to '?' for http
  2169.                 StrExtendCat( &httppath, fQuery);
  2170.                 }
  2171.             if (fHaveReply) {
  2172.                 Boolean isHTMLPostForm= (fHasAsk == 5);
  2173.                 //Boolean isHTMLForm= (fHasAsk == 3 || fHasAsk == 5);
  2174.                 //fQueryPlus= fReplyData;   << this is set in ReadTask
  2175.                 if (isHTMLPostForm) {
  2176.                     postdata= fReplyData;
  2177.                     }
  2178.                 else { // GET form
  2179.                     StrExtendCat( &httppath, "?");
  2180.                     StrExtendCat( &httppath, fReplyData);
  2181.                     }
  2182.                 }
  2183.                 
  2184.             fTalker->OpenQuery( fLink+fIhost, fPort, httppath, NULL, 
  2185.                                             NULL, postdata, NULL);
  2186.             MemFree(httppath);
  2187.             }
  2188.             break;
  2189.         
  2190.             
  2191.         case kFTPprot:     // file:///path:to:file
  2192.         case kFileprot: 
  2193.         //?? kCSOprot:
  2194.         case kWAISprot:
  2195.         case kTelnetprot:
  2196.         case kTN3270prot:
  2197.         case kPOPprot:
  2198.         case kNNTPprot:
  2199.         case kSMTPprot:
  2200.         default:
  2201.             break;
  2202.             
  2203.         }
  2204.     fQueryPlus= NULL; // set to zero after each call?
  2205.     fQuery= NULL;
  2206.     fBytesExpected= kReadToClose;
  2207.     fBytesReceived= 0;
  2208.     fConnectTime= 0;
  2209.  
  2210.     // If this is gopher+ server, then it will send first line as one of these
  2211.     //    which we must eat here...
  2212.     //    +12345<crlf>        number of bytes of data
  2213.     //    +-1<crlf>                data to dot-cr-lf
  2214.     //    +-2<crlf>                data to close-of-connection
  2215.  
  2216.     //if (fIsPlus != kGopherPlusNo) // << this is bad -- do w/o and trust checks of +##, --1 to work
  2217.     if (fProtocol == kGopherprot) 
  2218.     { 
  2219.         char* aLine= fTalker->RecvLine();
  2220.         if (aLine) {
  2221.         
  2222.             if (*aLine == '+' && (strlen(aLine) < 20 || fIsPlus == kGopherPlusYes)) {
  2223.                 fBytesExpected = atol( aLine+1);
  2224.                 DeleteInfo(); // zero it...
  2225.                     // bug in kTCPStopAtdotcrlf, switch it to kTCPStopAtclose for now...
  2226.                 if (fBytesExpected == kReadToDotCRLF) fBytesExpected= kReadToClose;
  2227.                 else if (fBytesExpected > 0) fTransferType= kTransferBinary; //?? always?
  2228.                 MemFree( aLine);
  2229.                 }
  2230.                 
  2231.             else if ( StrStr( aLine,"--1") == aLine) {
  2232.                         ////  error message:
  2233.                         //--1
  2234.                         //1 Don Gilbert <Archive@Bio.Indiana.Edu>
  2235.                         //0- Cannot access that directory
  2236.                         //  1== Item is not available, 2 == Try again later, 3 == Item has moved...
  2237.                 char* serror = (char*)gEmptyString;
  2238.                 char* smail= fTalker->RecvLine();
  2239.                 if (smail) {
  2240.                     long len= strlen(smail);
  2241.                     if (smail[len] == kCR) smail[len]= 0;
  2242.                     serror= fTalker->RecvLine();
  2243.                     if (serror) {
  2244.                         len= strlen(serror);
  2245.                         if (serror[len] == kCR) serror[len]= 0;
  2246.                         }
  2247.                     }
  2248.                 //CloseQuery();
  2249.                 DeleteInfo(); // zero it...
  2250.                 Nlm_Message (MSG_ERROR, "Gopher server error: %s %s", smail, serror);
  2251.                 fBytesExpected= 0;
  2252.                 fThreadState= kThreadDoneReading; // need an error state ??
  2253.                 fTalker->SetEndOfMessage(true);
  2254.                 MemFree( aLine);
  2255.                 return;
  2256.                 }
  2257.                 
  2258.             else {
  2259.                 //long linelen= StrLen(aLine);
  2260.                 //MemExtendCat( &fInfo, fInfoSize, aLine, linelen+1);
  2261.                 MemFree( fInfo);
  2262.                     // patch for binary data w/ nulls
  2263.                 fInfoSize= fTalker->NewBytesReceived();
  2264.                 fInfo= aLine; // aLine is made new in RecvLine()
  2265.                 if ( MemChr(aLine, 0, fInfoSize-1) != NULL)  
  2266.                     fTransferType= kTransferBinary; //kTransferText;
  2267.                 }
  2268.             }
  2269.         }
  2270. }
  2271.  
  2272.  
  2273. void DGopher::CloseQuery()
  2274. {
  2275.     if (fIsLocal) {
  2276.         if (fReplyFile) delete fReplyFile;
  2277.         fReplyFile= NULL;
  2278.         }
  2279.     else if (fTalker) {
  2280.         fBytesReceived= fTalker->TotalBytesReceived();
  2281.         fConnectTime= fTalker->ConnectTime();
  2282.         delete fTalker; 
  2283.         }
  2284.     ClearAskReply();  
  2285.     fTalker= NULL; 
  2286.     fThreadState= kThreadDoneReading;
  2287. }
  2288.  
  2289.  
  2290. void DGopher::ReadAChunk( long maxchunk)
  2291. {
  2292.   //fThreadState= kThreadStarted;
  2293.     if (fIsLocal && fReplyFile) {
  2294.         char* data;
  2295.         ulong datalen;
  2296.     
  2297.         if (maxchunk <= 0 || maxchunk > 32000) maxchunk = 32000;
  2298.         data = (char*)MemNew( maxchunk+1);
  2299.         datalen= MIN( fBytesExpected - fBytesReceived, maxchunk);
  2300.         fReplyFile->ReadData(data, datalen);
  2301.         if (datalen>0) {
  2302.             data[datalen]= 0;
  2303.             if (fInfo == NULL || fInfoSize == 0) {
  2304.                 if (fInfo) MemFree( fInfo);
  2305.                 fInfo= data; data= NULL; //fInfo= (char*) MemDup(data, datalen+1);
  2306.                 fInfoSize= datalen;
  2307.                 }
  2308.             else {
  2309.                 MemExtendCat( &fInfo, fInfoSize, data, datalen+1); // +1 for 0
  2310.                 fInfoSize += datalen;
  2311.                 }
  2312.             fBytesReceived += datalen;
  2313.             }
  2314.         MemFree( data);
  2315.         if (fReplyFile->EndOfFile() || datalen<maxchunk)     
  2316.             fThreadState= kThreadDoneReading;
  2317.         }
  2318.     else if (fTalker) {
  2319.         fInfo= fTalker->ReadWithChecks(fInfoSize, fBytesExpected, (fTransferType == kTransferText), 
  2320.                                         maxchunk, fInfo);
  2321.         }
  2322.     //fThreadState= kThreadDataOld;
  2323. }
  2324.  
  2325.  
  2326. void DGopher::ReadTask() 
  2327. {    
  2328.     fThreadState= kThreadNotStarted; // ! need to reset this somewhere for used gophers
  2329.     if (fHasAsk && fHaveReply) {  // && fThreadState == kThreadNotStarted
  2330.         fQueryPlus= fReplyData;  
  2331.         }
  2332.     OpenQuery();
  2333.     if (fThreadState == kThreadDoneReading) return;
  2334.     DTask* readTask= newTask(cRead, kGopherTask);
  2335.     readTask->SetRepeat(true);
  2336.     PostTask(readTask);
  2337. }
  2338.  
  2339. void DGopher::InfoTask() 
  2340. {    
  2341.     fThreadState= kThreadNotStarted; // ! need to reset this somewhere for used gophers
  2342.     fQueryPlus= "\t!"; 
  2343.     DGopher::OpenQuery(); // bypass class overrides of OpenQuery, which set fQueryPlus !!
  2344.     if (fThreadState == kThreadDoneReading) return;
  2345.     DTask* aTask= newTask(cInfo, kGopherTask);
  2346.     aTask->SetRepeat(true);
  2347.     PostTask(aTask);
  2348. }
  2349.  
  2350. Boolean DGopher::IsMyTask(DTask* theTask) 
  2351. {
  2352.     if (theTask->fKind == kGopherTask) {
  2353.         ProcessTask( theTask);
  2354.         return true;
  2355.         }
  2356.     else 
  2357.         return DTaskMaster::IsMyTask(theTask);
  2358. }
  2359.  
  2360. void DGopher::ProcessTask(DTask* theTask) 
  2361. {
  2362.     Boolean more;
  2363.     if (theTask->fNumber == cRead) {
  2364.         if (fIsLocal)
  2365.             more= (fReplyFile && !fReplyFile->EndOfFile() 
  2366.                         && (fBytesExpected - fBytesReceived)>0);
  2367.         else
  2368.             more= (fTalker && !fTalker->EndOfMessage());
  2369.         if (more)
  2370.             ReadAChunk(kReadMaxbuf1);
  2371.         else {
  2372.             theTask->SetRepeat(false);
  2373.             FinishRead();
  2374.             CloseQuery();
  2375.             }
  2376.         }
  2377.         
  2378.     else if (theTask->fNumber == cInfo) {
  2379.         if (fIsLocal)
  2380.             more= false;
  2381.         else
  2382.             more= (fTalker && !fTalker->EndOfMessage());
  2383.         if (more) 
  2384.             ReadAChunk(kReadMaxbuf1);
  2385.         else {
  2386.             theTask->SetRepeat(false);
  2387.             FinishRead();
  2388.             CloseQuery();
  2389.             
  2390.             if (fInfo && fInfoSize > 0) {
  2391.                 if (*fInfo == '+') fIsPlus = kGopherPlusYes;
  2392.                 else fIsPlus= kGopherPlusNo;
  2393.                 }
  2394.             SetPlusInfo( fIsPlus, fHasAsk, fInfo); // is fInfo safe for use? seems okay
  2395.             
  2396.             char *info= (char*) MemGet(1,true);
  2397.             this->ToServerText( info, 0);
  2398.             
  2399.             if (fIsPlus == kGopherPlusYes) {
  2400.                 // tack on all but first +INFO: line
  2401.                 char *cp, *ep;
  2402.                 char endbuf[6];
  2403.                 StrNCpy( endbuf, LineEnd, 4);
  2404.                 StrCat( endbuf, "#");
  2405.                 cp = StrChr(fInfo,*LineEnd);
  2406.                 while (cp) {
  2407.                     cp++;
  2408.                     ep= StrChr( cp, *LineEnd);
  2409.                     if (ep) *ep= 0;
  2410.                     StrExtendCat( &info, endbuf);
  2411.                     StrExtendCat( &info, cp);
  2412.                     cp= ep; if (cp) cp += LineEndSize;
  2413.                     }
  2414.                 StrExtendCat( &info, LineEnd);
  2415.                 }
  2416.                 
  2417.             MemFree( fInfo);
  2418.             fInfo= info;
  2419.             fInfoSize= StrLen(info);
  2420.             fThreadState= kThreadDoneReading;
  2421.             }
  2422.         }
  2423. }
  2424.  
  2425.  
  2426.  
  2427.  
  2428.  
  2429.  
  2430.  
  2431. short DGopher::CommandResult()
  2432. {
  2433.         // ?? mapping of command due to mapping of these values ?? see CGopherMap
  2434.         return fCommand;
  2435. }
  2436.  
  2437.  
  2438. void DGopher::SetAskReply( CharPtr data, DFile* replyFile)
  2439. {
  2440.     if (fHasAsk && (data || replyFile)) {
  2441.         fHaveReply= true;
  2442.         fReplyData= data;
  2443.         fReplyFile= replyFile;
  2444.         }
  2445. }
  2446.  
  2447. void DGopher::ClearAskReply()
  2448. {
  2449.     if (fReplyData) {
  2450.         fReplyData= (char*) MemFree( fReplyData);
  2451.         }
  2452.     //fReplyFile= (DFile*) FreeIfObject( fReplyFile); !!NO, leave this to creator of DFile !
  2453.     fReplyFile= NULL;
  2454.     fHaveReply= false;
  2455. }
  2456.  
  2457.  
  2458.  
  2459. short DGopher::ThreadProgress(short /*update*/)
  2460. {
  2461.     if (fTalker) {
  2462.         fBytesReceived= fTalker->TotalBytesReceived();
  2463.         fConnectTime= fTalker->ConnectTime();
  2464.         }
  2465.     return fThreadState;
  2466. }
  2467.  
  2468.  
  2469. short DGopher::ItemForm(short viewchoice)
  2470. {
  2471.             // we don't want to repeat mapping here and in DoIt() !!
  2472.     if (fViews && (fViews->GetSize()>0) && gGopherMap) {
  2473.         if (viewchoice<0) fViewchoice= 0; else fViewchoice= viewchoice;
  2474.         DGopherMap* mapper= gGopherMap->MatchHandlerKind( this);
  2475.         if (mapper) mapper->Map(this);
  2476.         }
  2477.  
  2478.     fViewchoice= viewchoice;
  2479.     if (viewchoice == kGetItemInfo) 
  2480.         return cGopherGetInfo;
  2481.     else if (fHasAsk) {
  2482.         if (fHaveReply)  
  2483.             return this->CommandResult();
  2484.         else  
  2485.             return cNewGopherAsk;
  2486.         }
  2487.     else
  2488.         return this->CommandResult();        
  2489. }
  2490.  
  2491.  
  2492. //Local ??
  2493. inline void GoDrawLine( Nlm_RecT& area, char* str)
  2494. {
  2495.     if (str) {
  2496.         Nlm_DrawString(&area, str, 'l', false);
  2497. #ifndef WIN_MAC
  2498.             // XWin/MWin DrawString doesn't set NlmPoint (GetPoint fails to move)
  2499.         Nlm_MoveTo( area.left + Nlm_StringWidth(str), area.top);
  2500. #endif
  2501.         }
  2502. }
  2503.  
  2504. void DGopher::DrawTitle( Nlm_RecT& area)  
  2505. {
  2506.     ::GoDrawLine( area, fLink + fItitle);
  2507. }
  2508.  
  2509. short DGopher::WidthTitle()  
  2510. {
  2511.     if (fLink) return Nlm_StringWidth( fLink + fItitle);
  2512.     else return 0;
  2513. }
  2514.  
  2515.  
  2516. void DGopher::DrawAbstract( Nlm_RecT& area)  
  2517. {
  2518.     if (fAbstract) fAbstract->Draw( area);
  2519. }
  2520.  
  2521. short DGopher::HeightAbstract()  
  2522. {
  2523.     if (fAbstract) return fAbstract->Height();
  2524.     else return 0;
  2525. }
  2526.  
  2527.  
  2528. void DGopher::DrawAdmin( Nlm_RecT& area)  
  2529. {
  2530.     ::GoDrawLine( area, fAdminEmail);
  2531. }
  2532.  
  2533. short DGopher::WidthAdmin()  
  2534. {
  2535.     if (fAdminEmail) return Nlm_StringWidth( fAdminEmail);
  2536.     else return 0;
  2537. }
  2538.  
  2539.  
  2540. void DGopher::DrawPlus( Nlm_RecT& area)  
  2541. {
  2542.     char* str= NULL;
  2543.     if (fIsMap) str= "#";
  2544.     else if (fHasAsk) str= "?";
  2545.     else if (fIsPlus >= kGopherPlusYes) str= "+";
  2546.     ::GoDrawLine( area, str);
  2547. }
  2548.  
  2549. short DGopher::WidthPlus()  
  2550. {
  2551.  return Nlm_StringWidth("?");
  2552. }
  2553.  
  2554.  
  2555. void DGopher::DrawKind( Nlm_RecT&  area)  
  2556. {
  2557.     ::GoDrawLine( area, (char*) GetKindName());
  2558. }
  2559.  
  2560. short DGopher::WidthKind()  
  2561. {
  2562.     return Nlm_StringWidth( (char*)GetKindName());
  2563. }
  2564.  
  2565.  
  2566. void DGopher::DrawDate( Nlm_RecT& area)  
  2567. {
  2568.     char* str= NULL;
  2569.     if (fDate) str= fDate;
  2570.     else if (fIdate) str= fLink + fIdate;
  2571.     ::GoDrawLine( area, str);
  2572. }
  2573.  
  2574. short DGopher::WidthDate()  
  2575. {
  2576.     if (fDate) return Nlm_StringWidth( fDate);
  2577.     else if (fIdate) return Nlm_StringWidth( fLink + fIdate);
  2578.     else return 0;
  2579. }
  2580.  
  2581.  
  2582. void DGopher::DrawSize( Nlm_RecT& area)  
  2583. {
  2584.     char* str= NULL;
  2585.     if (fDataSize) ::GoDrawLine( area, fDataSize);
  2586.     else if (fIsize) ::GoDrawLine( area, fLink + fIsize);
  2587. }
  2588.  
  2589. short DGopher::WidthSize()  
  2590. {
  2591.     if (fDataSize) return Nlm_StringWidth( fDataSize);
  2592.     else if (fIsize) return Nlm_StringWidth( fLink + fIsize);
  2593.     else return 0;
  2594. }
  2595.  
  2596. void DGopher::DrawPath( Nlm_RecT& area)  
  2597. {
  2598.  if (fIpath) ::GoDrawLine( area, fLink + fIpath);
  2599. }
  2600.  
  2601. short DGopher::WidthPath()  
  2602. {
  2603.     if (fIpath) return Nlm_StringWidth( fLink + fIpath);
  2604.     else return 0;
  2605. }
  2606.  
  2607.  
  2608. void DGopher::DrawHost( Nlm_RecT& area)  
  2609. {
  2610.     if (fIhost) ::GoDrawLine( area, fLink + fIhost);
  2611. }
  2612.  
  2613. short DGopher::WidthHost()  
  2614. {
  2615.     if (fIhost) return Nlm_StringWidth( fLink + fIhost);
  2616.     else return 0;
  2617. }
  2618.  
  2619. void DGopher::DrawPort( Nlm_RecT& area)  
  2620. {
  2621.     char snum[256];
  2622.     Dgg_LongToStr( fPort, snum, 0, 255);
  2623.     ::GoDrawLine( area, snum);
  2624. }
  2625.  
  2626. short DGopher::WidthPort()  
  2627. {
  2628.     char snum[256];
  2629.     Dgg_LongToStr( fPort, snum, 0, 255);
  2630.     return Nlm_StringWidth(snum);
  2631. }
  2632.  
  2633. void DGopher::DrawURL( Nlm_RecT& area)  
  2634. {
  2635.     ::GoDrawLine( area, (char*)GetURL());
  2636. }
  2637.  
  2638.  
  2639. void DGopher::DrawIconSub( Nlm_RecT& area) 
  2640. {
  2641.     short idplus;
  2642.     DIcon* ico= NULL;
  2643.     switch (gIconSize) {
  2644.         case 0 : idplus= 20000; break;
  2645.         case 1 : idplus= 10000; break;
  2646.         case 2 : 
  2647.         default: idplus= 0; break;
  2648.         }
  2649.         
  2650.     if (gGopherIcons) ico= gGopherIcons->IconById( gGopherIconID + idplus); 
  2651.     Nlm_InsetRect( &area,1,1); //? do we really want this?
  2652.     if (ico) ico->Draw(area);
  2653. }
  2654.  
  2655. void DGopher::DrawIcon( Nlm_RecT& area, short size)  
  2656. {
  2657.     gGopherIconID= kDefaultIcon;
  2658.     gIconSize= size;
  2659.     DrawIconSub( area);
  2660. }
  2661.  
  2662. short DGopher::WidthIcon(short size)  
  2663. {
  2664.     switch (size) {
  2665.         case 0 : return 16;  //12 + 4
  2666.         case 1 : return 20;  //16 + 4
  2667.         case 2 : return 36; 
  2668.         default: return 36; 
  2669.         }
  2670. }
  2671.  
  2672.  
  2673.  
  2674.  
  2675.  
  2676.  
  2677. struct goTypeRec {
  2678.     char kind;
  2679.     const char* name;
  2680.     Boolean supported:1;
  2681.     };
  2682.  
  2683. Local goTypeRec gGopherTypes[] = {
  2684.     {kTypeFile, "Document", true},
  2685.     {kTypeFolder, "Folder", true},
  2686.     {kTypeQuery, "Query", true},
  2687.     {kTypeBinary, "Binary file", true},
  2688.     {kTypeImage, "Image", true},
  2689.     {kTypeSound, "Sound", true},
  2690.     {kTypeMovie, "Movie", true},
  2691.     {kTypeNote, "Note", true},
  2692.     {kTypeHtml, "HTML document", true},
  2693.     {kMailType, "Mailto", true},
  2694.     {kTypeTelnet, "Telnet link", false},
  2695.     {kTypeTn3270, "TN3270 link", false},
  2696. #if 0    
  2697.     {kTypeCSO, "CSO Phonebook", false},
  2698.     {kTypeWhois, "Whois Phonebook", false},
  2699.     {kTypeBinhex, "Binhex file", false},
  2700.     {kTypeUuencode, "Uuencoded file", false},
  2701. #endif
  2702.     {kTypeError, "Unknown type", true},
  2703.     {0,0} 
  2704.     };
  2705.  
  2706.  
  2707. //static
  2708. const char* DGopher::GetTypeName( short listitem)
  2709. {
  2710.     if (listitem>=0 && listitem < (sizeof(gGopherTypes) / sizeof(goTypeRec)))
  2711.         return gGopherTypes[listitem].name;
  2712.     else
  2713.         return NULL;
  2714. }
  2715.  
  2716. char DGopher::GetTypeVal( short listitem)
  2717. {
  2718.     if (listitem>=0 && listitem < (sizeof(gGopherTypes) / sizeof(goTypeRec)))
  2719.         return gGopherTypes[listitem].kind;
  2720.     else
  2721.         return 0;
  2722. }
  2723.  
  2724. Boolean DGopher::GetTypeSupport( short listitem)
  2725. {
  2726.     if (listitem>=0 && listitem < (sizeof(gGopherTypes) / sizeof(goTypeRec)))
  2727.         return gGopherTypes[listitem].supported;
  2728.     else
  2729.         return 0;
  2730. }
  2731.  
  2732. short DGopher::GetTypeItem( char theType)
  2733. {
  2734.     short i;
  2735.     for (i=0; i < (sizeof(gGopherTypes) / sizeof(goTypeRec)); i++) {
  2736.         if (gGopherTypes[i].kind == theType) return i;
  2737.       }
  2738.     return -1;
  2739. }
  2740.  
  2741.  
  2742.  
  2743. Local goTypeRec gProtoTypes[] = {
  2744.     { DGopher::kGopherprot, "gopher://", true },
  2745.     { DGopher::kHTTPprot, "http://", true },
  2746.     { DGopher::kFileprot, "file://", true },
  2747.     { DGopher::kFTPprot, "ftp://", true },
  2748.     { DGopher::kSMTPprot,"mailto:", true },
  2749.     { DGopher::kWAISprot, "wais://", false },
  2750.     { DGopher::kTelnetprot, "telnet://", false },
  2751.     { DGopher::kTN3270prot, "tn3270://", false },
  2752.     { DGopher::kNNTPprot, "news:", false },
  2753.     { DGopher::kFingerprot, "finger:", true },
  2754.     { DGopher::kWhoisprot, "whois:", true },
  2755.     { DGopher::kUnsupportedProt, "unsupported://", true },
  2756.     { DGopher::kUnknownProt, "unknown://", true },
  2757.     {0,0}
  2758.     };
  2759.  
  2760. //static
  2761. const char* DGopher::GetProtoName( short listitem)
  2762. {
  2763.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(goTypeRec)))
  2764.         return gProtoTypes[listitem].name;
  2765.     else
  2766.         return NULL;
  2767. }
  2768.  
  2769. char DGopher::GetProtoVal( short listitem)
  2770. {
  2771.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(goTypeRec)))
  2772.         return gProtoTypes[listitem].kind;
  2773.     else
  2774.         return 0;
  2775. }
  2776.  
  2777. Boolean DGopher::GetProtoSupport( short listitem)
  2778. {
  2779.     if (listitem>=0 && listitem < (sizeof(gProtoTypes) / sizeof(goTypeRec)))
  2780.         return gProtoTypes[listitem].supported;
  2781.     else
  2782.         return 0;
  2783. }
  2784.  
  2785. short DGopher::GetProtoItem( char theProto)
  2786. {
  2787.     short i;
  2788.     for (i=0; i < ( sizeof(gProtoTypes) / sizeof(goTypeRec)); i++) {
  2789.         if (gProtoTypes[i].kind == theProto) return i;
  2790.       }
  2791.     return -1;
  2792. }
  2793.  
  2794.  
  2795.  
  2796.  
  2797.